// Use this for initialization
        void Awake()
        {
            spriteRend = GetComponent<SpriteRenderer> ();
            collider = GetComponent<PolygonCollider2D> ();

            //DestroyPlanetChunk ();
        }

	// Use this for initialization
	void Start () {
		area = this.gameObject.GetComponent<PolygonCollider2D> (); 
		/*Vector3[] passIn = new Vector3[points.Length]; 
		for (int i = 0; i < points.Length; i++)
			passIn [i] = points [i].transform.position; 
		SetCollider (passIn); */
	}

 void Start()
 {
     base.Start();
     anim = GetComponent<Animator>();
     rigid = GetComponent<Rigidbody2D>();
     collider = GetComponent<PolygonCollider2D>();
 }

		override public void AssignValues (List<ActionParameter> parameters)
		{
			SceneSettings sceneSettings = GameObject.FindWithTag (Tags.gameEngine).GetComponent <SceneSettings>();

			if (sceneSetting == SceneSetting.DefaultNavMesh)
			{
				if (sceneSettings.navigationMethod == AC_NavigationMethod.PolygonCollider && changeNavMeshMethod == ChangeNavMeshMethod.ChangeNumberOfHoles)
				{
					hole = AssignFile <PolygonCollider2D> (parameters, parameterID, constantID, hole);
				}
				else
				{
					newNavMesh = AssignFile <NavigationMesh> (parameters, parameterID, constantID, newNavMesh);
				}
			}
			else if (sceneSetting == SceneSetting.DefaultPlayerStart)
			{
				playerStart = AssignFile <PlayerStart> (parameters, parameterID, constantID, playerStart);
			}
			else if (sceneSetting == SceneSetting.SortingMap)
			{
				sortingMap = AssignFile <SortingMap> (parameters, parameterID, constantID, sortingMap);
			}
			else if (sceneSetting == SceneSetting.OnLoadCutscene || sceneSetting == SceneSetting.OnStartCutscene)
			{
				cutscene = AssignFile <Cutscene> (parameters, parameterID, constantID, cutscene);
			}
		}

 public override void AssignValues(List<ActionParameter> parameters)
 {
     if (sceneSetting == SceneSetting.DefaultNavMesh)
     {
         if (KickStarter.sceneSettings.navigationMethod == AC_NavigationMethod.PolygonCollider && changeNavMeshMethod == ChangeNavMeshMethod.ChangeNumberOfHoles)
         {
             hole = AssignFile <PolygonCollider2D> (parameters, parameterID, constantID, hole);
             replaceHole = AssignFile <PolygonCollider2D> (parameters, replaceParameterID, replaceConstantID, replaceHole);
         }
         else
         {
             newNavMesh = AssignFile <NavigationMesh> (parameters, parameterID, constantID, newNavMesh);
         }
     }
     else if (sceneSetting == SceneSetting.DefaultPlayerStart)
     {
         playerStart = AssignFile <PlayerStart> (parameters, parameterID, constantID, playerStart);
     }
     else if (sceneSetting == SceneSetting.SortingMap)
     {
         sortingMap = AssignFile <SortingMap> (parameters, parameterID, constantID, sortingMap);
     }
     else if (sceneSetting == SceneSetting.SortingMap)
     {
         tintMap = AssignFile <TintMap> (parameters, parameterID, constantID, tintMap);
     }
     else if (sceneSetting == SceneSetting.OnLoadCutscene || sceneSetting == SceneSetting.OnStartCutscene)
     {
         cutscene = AssignFile <Cutscene> (parameters, parameterID, constantID, cutscene);
     }
 }

	// Use this for initialization
	void Awake () {
        ignoreCollisionList = new List<Collider2D>();

        rigid = GetComponent<Rigidbody2D>();

        ball = this.gameObject.AddComponent<PolygonCollider2D>();
        ball.sharedMaterial = ballPhysicsMat;

        rend = GetComponent<LineRenderer>();

        Vector2[] points = new Vector2[2 * (numSides + 1)];
        rend.SetVertexCount(numSides + 1);

        float visualRadius = (outerRadius + innerRadius) / 2;
        rend.SetWidth(outerRadius - innerRadius, outerRadius - innerRadius);

        // inner points
        for (int i = 0; i <= numSides; i++)
        {
            float angle = TwoPI * i / numSides;
            Vector2 direction = new Vector2(Mathf.Cos(angle), Mathf.Sin(angle));
            points[i] = innerRadius * direction;
            rend.SetPosition(i, visualRadius * direction);

        }

        // outer points
        for (int i = numSides + 1; i < points.Length; i++)
        {
            float angle = TwoPI * i / numSides;
            points[i] = new Vector2(outerRadius * Mathf.Cos(angle), outerRadius * Mathf.Sin(angle));
        }

        ball.points = points;
	}

    //---------------------------------------------------------------------------------------------

    protected virtual void OnDrawGizmos()
    {
        Follow();

        if (!m_pCollider)
            m_pCollider = GetComponent<PolygonCollider2D>();

        Vector2[] points = m_pCollider.points;
        Vector2 p2D = transform.position;

        if (points == null) return;

        Vector3 pointCurrent, pointNext;
        Vector3 angles = transform.rotation.eulerAngles;

        for (var i = 0; i < points.Length - 1; i++)
        {
            pointCurrent = KDTools.Adjust(points[i], p2D, angles, transform.localScale);
            pointNext = KDTools.Adjust(points[i + 1], p2D, angles, transform.localScale);
            Gizmos.DrawLine(pointCurrent, pointNext);
        }

        pointCurrent = KDTools.Adjust
                       (
                            points[points.Length - 1], 
                            p2D, 
                            angles,
                            transform.localScale
                        );

        pointNext = KDTools.Adjust(points[0], p2D, angles, transform.localScale);

        Gizmos.DrawLine(pointCurrent, pointNext);
    }

    public void DrawAsteroid()
    {
        var drawObject = GetComponent<LineRendererDrawer>();
        polyCollider = GetComponent<PolygonCollider2D>();
        var linePoints = circleSegments + 1;
        var polyPoints = new Vector2[linePoints];
        var drawPoints = new List<Vector2>();
        float part = 360f / circleSegments;
        int i = 0;
        while (i < linePoints)
        {
            float duh = part * i * (2 * Mathf.PI / 360) * -1 + Mathf.PI / 2;
            Vector3 pos = new Vector3((Mathf.Cos(duh) * radius), (Mathf.Sin(duh) * radius), 0);

            if (i != 0 && i != (linePoints - 1))
            {
                pos = new Vector3(pos.x + Random.Range(-radius / 4, radius / 4), pos.y + Random.Range(-radius / 4, radius / 4), 0);
            }

            drawPoints.Add(pos);
            polyPoints[i] = new Vector2(pos.x, pos.y);
            i++;
        }
        drawObject.SetPoints(drawPoints);
        polyCollider.points = polyPoints;
    }

    void Awake()
    {
        lightMesh = new Mesh();
        lightMesh.name = string.Format("Light Mesh ({0})", name);
        lightMesh.MarkDynamic();

        meshFilter = GetComponent<MeshFilter>();
        meshFilter.mesh = lightMesh;

        meshRenderer = GetComponent<MeshRenderer>();
        meshRenderer.sharedMaterial = lightMaterial;

        var container = transform.Find("LightMesh");
        if (!container)
        {
            container = new GameObject("LightMesh").transform;
            container.SetParent(transform, true);
            container.localPosition = Vector3.zero;
            container.gameObject.layer = gameObject.layer;
        }

        lightMeshCollider = container.GetComponent<PolygonCollider2D>();
        if (lightMeshCollider == null)
        {
            lightMeshCollider = container.gameObject.AddComponent<PolygonCollider2D>();
        }

        lightMeshCollider.isTrigger = true;

        vertices = new List<Vertex>();

        UpdateLightFX();
    }

 void Start()
 {
     hitbox = gameObject.AddComponent<PolygonCollider2D>();
     hitbox.isTrigger = true;
     AudioSource.PlayClipAtPoint(Resources.Load<AudioClip>("Skills/Slash/slash_" + Random.Range(0,3).ToString()), gameObject.transform.position);
     StartCoroutine("playAnimation", attackSpeed);
 }

	// ============= GENERATION ==============
	private void Awake() {
		allPoints = new List<Point>();
		edgePoints = new List<Point>();
		finishingPoints = new List<Point>();
		polygonCollider = GetComponent<PolygonCollider2D>();
		mesh = GetComponent<TriangulatedMesh>();
	}

    public override void RebuildAllColliders()
    {
        UpdateCollidable();

        DestroyCollider();

        var alphaTex = destructibleSprite.AlphaTex;

        if (alphaTex != null)
        {
            var spriteRenderer = D2D_Helper.GetOrAddComponent<SpriteRenderer>(child);
            var sprite         = Sprite.Create(alphaTex, new Rect(0, 0, alphaTex.width, alphaTex.height), Vector2.zero, 1.0f, 0, SpriteMeshType.FullRect);

            spriteRenderer.sprite = sprite;

            collider = child.AddComponent<PolygonCollider2D>();

            // Disable the collider if it couldn't form any triangles
            collider.enabled = IsDefaultPolygonCollider2D(collider) == false;

            D2D_Helper.Destroy(sprite);
            D2D_Helper.Destroy(spriteRenderer);

            UpdateColliderSettings();
        }
    }

    // Use this for initialization
    void Start()
    {

        audio = gameObject.GetComponent<AudioSource>();
        rb = GetComponent<Rigidbody2D>();
        collision = GetComponent<PolygonCollider2D>();
    }

 private void MakeBounds(PolygonCollider2D source)
 {
     if (source.renderer == null)
     {
     Vector2[] points = source.points;
     float maxX = float.NegativeInfinity;
     float maxY = float.NegativeInfinity;
     foreach (Vector2 point in points)
     {
         if (point.x > maxX)
         {
             maxX = point.x;
         }
         if (point.y > maxY)
         {
             maxY = point.y;
         }
     }
     Vector2 maxSize = new Vector2(maxX, maxY);
     Vector2 pos = source.transform.position;
     Vector2 polySize = maxSize - pos;
     MakeBounds(source.gameObject, polySize, Vector2.zero);
     }
     else
     {
     MakeBounds(source.renderer);
     }
 }

    void Reset()
    {

        gameObject.name = "@PolyNav2D";
        masterCollider = GetComponent<PolygonCollider2D>();
        masterCollider.isTrigger = true;
    }

	// Use this for initialization
    protected override void Awake()
    {
        base.Awake();
		vfx = GetComponent<ParticleSystem>();
		coll = GetComponent<PolygonCollider2D>();
		effector = GetComponent<PointEffector2D>();
	}

 void Start()
 {
     // Create a polygon collider
     localCollider = gameObject.AddComponent<PolygonCollider2D>();
     localCollider.isTrigger = true; // Set as a trigger so it doesn't collide with our environment
     localCollider.pathCount = 0; // Clear auto-generated polygons
 }

	// Use this for initialization
	void Start () {
        this.currentState = "Square"; // Game starts with Square
        this.animator = this.GetComponent<Animator>();
        this.currentDirection = 1; // 1 for RIGHT / -1 for LEFT

        this.world = GameObject.Find("World");
        this.isStucked = false;
        this.isControllerLocked = false;

        //Initialize the sounds
        /*this.fitTargetSound = this.audioPrefab.transform.GetChild(0).GetComponent<AudioSource>();
        this.dieSound = this.audioPrefab.transform.GetChild(1).GetComponent<AudioSource>();
        this.landscapeSound = this.audioPrefab.transform.GetChild(2).GetComponent<AudioSource>();
        this.changeSound = this.audioPrefab.transform.GetChild(3).GetComponent<AudioSource>();
        this.bounceSound = this.audioPrefab.transform.GetChild(4).GetComponent<AudioSource>();
        */
        //Grab the colliders
        this.SquareCollider = this.GetComponent<BoxCollider2D>();
        this.CircleCollider = this.GetComponent<CircleCollider2D>();
        this.TriangleCollider = this.GetComponent<PolygonCollider2D>();

        //Grab the Rigidbody
        this.rigidBody = this.GetComponent<Rigidbody2D>();
        this.setRigidbody();
	}

    void Awake()
    {
        rigidbody = GetComponent<Rigidbody2D>();
        body = GetComponent<PolygonCollider2D>();
        feet = GetComponent<CircleCollider2D>();
        health = GetComponent<Health>();
        standing = body.points;
        crouched = new Vector2[standing.Length];
        grounded = false;
        onWall = false;
        upSlope = false;
        downSlope = false;

        int min = 0;
        for (int i = 0; i < standing.Length; i++)
        {
            if (standing[i].y < standing[min].y)
                min = i;
        }
        for (int i = 0; i < standing.Length; i++)
        {
            float newY = (standing[i].y - standing[min].y) * 0.5f + standing[min].y;
            crouched[i] = new Vector2(standing[i].x, newY);
        }
    }

 void Start()
 {
     Debug.Log("Started");
     gameObject.AddComponent<LineRenderer>();
     classpc = gameObject.AddComponent<PolygonCollider2D>();
     classpc.SetPath(0, new Vector2[] { });
     //classpc.SetPath(1, new Vector2[] { });
 }