Collider for 2D physics representing an arbitrary set of connected edges (lines) defined by its vertices.

Inheritance: Collider2D
Ejemplo n.º 1
0
	public void GenerateLevel ()
	{
		// Get a few pseudo random points
		Vector2[] randomPoints = RandomPoints( start, 300f, myPoints );
	
		//make points into a curve
		int res = 20; // Highter number increases edgeCount;
		List<Vector2> curveVerts = MultiCurve(randomPoints, res);
	
		//Generate colission using curve vertices
		generatedCol = SpawnCol ( curveVerts, Vector2.zero, Quaternion.identity );
		Vector3 heightOffset = new Vector3( 0f, roofOffset, 0f) ;
		generatedCol2 = SpawnCol( curveVerts, generatedCol.transform.position + heightOffset, Quaternion.identity );

		//Generate two 2D meshes that correspond with the collision
		generatedMesh = GenerateMesh2D( generatedCol, meshHeight, generatedCol.transform.position, Quaternion.identity );
		Vector3 heightOffsetMesh = new Vector3( 0f, roofOffset + meshHeight, 0f );
		generatedMesh2 = GenerateMesh2D( generatedCol, meshHeight, generatedCol.transform.position + heightOffsetMesh, Quaternion.identity );

		//Generate anchors
		GenerateAnchors( curveVerts, roofOffset );

		//Generate Obstacles
		GenerateObstacles ( curveVerts, roofOffset, 0.05f );

		//Spawn a checkpoint
		Vector3 cpPos = new Vector3( start.x + ( generatedMesh.GetComponent<MeshRenderer>().bounds.size.x * 0.66f ) , start.y, -0.1f );
		GameObject cp =  (GameObject)Instantiate( checkPointPrefab, cpPos, Quaternion.identity );
		cp.GetComponent<CheckPoint>().SetLevelGenerator( gameObject.GetComponent<LevelGeneratorNew>() );

		//Set next start position 
		start = generatedCol.points[generatedCol.pointCount - 1];

		cam.SetOffset(roofOffset);
	}
    public void drawCurve()
    {
        pts = new List<Vector2>();
        pts.Clear();

        edge = GetComponent<EdgeCollider2D>();
        if (edge == null)
        {
            gameObject.AddComponent<EdgeCollider2D>();
        }

        if (controlPoints.Count == 2)
        {
            drawSegment(controlPoints[0], controlPoints[1], handlerPoints[0], handlerPoints[1]);
        } else if (controlPoints.Count > 2)
        {
            int h = 0;
            for(int i = 0; i < controlPoints.Count - 1; i++)
            {
                drawSegment(controlPoints[i], controlPoints[i+1], handlerPoints[h], handlerPoints[h+1]);
                h += 2;
            }
        }


        edge.points = pts.ToArray();

    }
Ejemplo n.º 3
0
 void Awake()
 {
     col = GetComponent<EdgeCollider2D>();
     Vector2 pos = (Vector2)transform.position;
     if(col){
         Vector2[] newPoints = new Vector2[edgeSides.Length * 2];
         for(int i = 0; i < edgeSides.Length; i++){
             switch(edgeSides[i]){
                 case Sides.Top:
                     newPoints[2 * i] = new Vector2(-0.5f, 0.5f);
                     newPoints[2 * i + 1] = new Vector2(0.5f, 0.5f);
                     break;
                 case Sides.Bottom:
                     newPoints[2 * i] = new Vector2(-0.5f, -0.5f);
                     newPoints[2 * i + 1] = new Vector2(0.5f, -0.5f);
                     break;
                 case Sides.Left:
                     newPoints[2 * i] = new Vector2(-0.5f, -0.5f);
                     newPoints[2 * i + 1] = new Vector2(-0.5f, 0.5f);
                     break;
                 case Sides.Right:
                     newPoints[2 * i] = new Vector2(0.5f, 0.5f);
                     newPoints[2 * i + 1] = new Vector2(0.5f, -0.5f);
                     break;
             }
         }
         col.points = newPoints;
     }
 }
Ejemplo n.º 4
0
    void Awake()
    {
        edgeCollider = GetComponent<EdgeCollider2D>();

        thisCamera = Camera.main;
        lineRenderer = GetComponent<LineRenderer>();
    }
Ejemplo n.º 5
0
	void Start()
	{
		visinaZgrade = 9.5f; // Namestiti kasnije da bude visina po spratovima
		inRange = false;
		krovKolajder = GetComponentInChildren<EdgeCollider2D> ();
		krovKolajder.enabled = false;
	}
 static void EdgeCollider2D_points(JSVCall vc)
 {
     if (vc.bGet)
     {
         UnityEngine.EdgeCollider2D _this = (UnityEngine.EdgeCollider2D)vc.csObj;
         var result = _this.points;
         var arrRet = result;
         for (int i = 0; arrRet != null && i < arrRet.Length; i++)
         {
             JSApi.setVector2S((int)JSApi.SetType.SaveAndTempTrace, arrRet[i]);
             JSApi.moveSaveID2Arr(i);
         }
         JSApi.setArrayS((int)JSApi.SetType.Rval, (arrRet != null ? arrRet.Length : 0), true);
     }
     else
     {
         UnityEngine.Vector2[] arg0 = JSDataExchangeMgr.GetJSArg <UnityEngine.Vector2[]>(() =>
         {
             int jsObjID = JSApi.getObject((int)JSApi.GetType.Arg);
             int length  = JSApi.getArrayLength(jsObjID);
             var ret     = new UnityEngine.Vector2[length];
             for (var i = 0; i < length; i++)
             {
                 JSApi.getElement(jsObjID, i);
                 ret[i] = (UnityEngine.Vector2)JSApi.getVector2S((int)JSApi.GetType.SaveAndRemove);
             }
             return(ret);
         });
         UnityEngine.EdgeCollider2D _this = (UnityEngine.EdgeCollider2D)vc.csObj;
         _this.points = arg0;
     }
 }
Ejemplo n.º 7
0
    void Start()
    {
        edgeCollider = GetComponent<EdgeCollider2D>();
        mesh = GetComponent<MeshFilter>().mesh;

        SetupVerts();
    }
Ejemplo n.º 8
0
 void OnDrawGizmos() {
     edge = GetComponent<EdgeCollider2D>();
     min = edge.bounds.min;
     max = edge.bounds.max;
     Gizmos.color = Color.yellow;
     Gizmos.DrawLine(min, max);
 }
Ejemplo n.º 9
0
 static public int constructor(IntPtr l)
 {
     UnityEngine.EdgeCollider2D o;
     o = new UnityEngine.EdgeCollider2D();
     pushObject(l, o);
     return(1);
 }
Ejemplo n.º 10
0
 static public int set_edgeRadius(IntPtr l)
 {
     try {
                     #if DEBUG
         var    method     = System.Reflection.MethodBase.GetCurrentMethod();
         string methodName = GetMethodName(method);
                     #if UNITY_5_5_OR_NEWER
         UnityEngine.Profiling.Profiler.BeginSample(methodName);
                     #else
         Profiler.BeginSample(methodName);
                     #endif
                     #endif
         UnityEngine.EdgeCollider2D self = (UnityEngine.EdgeCollider2D)checkSelf(l);
         float v;
         checkType(l, 2, out v);
         self.edgeRadius = v;
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
             #if DEBUG
     finally {
                     #if UNITY_5_5_OR_NEWER
         UnityEngine.Profiling.Profiler.EndSample();
                     #else
         Profiler.EndSample();
                     #endif
     }
             #endif
 }
Ejemplo n.º 11
0
 public void Activate(Color c, EdgeCollider2D side)
 {
     colors.Add(c);
     hit = true;
     if (side.Equals(bottom))
     {
         bottomSprite.color = c;
     }
     else if (side.Equals(left))
     {
         leftSprite.color = c;
     }
     else if (side.Equals(right))
     {
         rightSprite.color = c;
     }
     SetColor(combineColors());
     middle.color = color;
     emitter.color = color;
     if (lastObject != null && lastObject.tag == "Laser Switch")
     {
         LaserSwitchBehavior l = lastObject.GetComponent<LaserSwitchBehavior>();
         l.resetActivate();
         l.Activate(color);
     }
 }
    static void EdgeCollider2D_pointCount(JSVCall vc)
    {
        UnityEngine.EdgeCollider2D _this = (UnityEngine.EdgeCollider2D)vc.csObj;
        var result = _this.pointCount;

        JSApi.setInt32((int)JSApi.SetType.Rval, (System.Int32)(result));
    }
Ejemplo n.º 13
0
 // Use this for initialization
 void Start()
 {
     lr = (this.renderer as LineRenderer);
     ec = (this.collider2D as EdgeCollider2D);
     lr.SetVertexCount(ec.pointCount);
     for (int i = 0; i < ec.pointCount; i++)
         lr.SetPosition(i, ec.points[i]);
 }
Ejemplo n.º 14
0
 public void GotoLadderState_FromSpine(EdgeCollider2D ladderSpine)
 {
     // Snap to the ladder
     Vector3 pos = this.transform.position;
     float ladder_x = ladderSpine.points [0].x;
     this.transform.position = new Vector3 (ladder_x, pos.y, pos.z);
     this.gameObject.GetComponent<BoxCollider2D> ().isTrigger = true;
 }
Ejemplo n.º 15
0
	internal CasterCollider(EdgeCollider2D coll){
		collider = coll;
		transform = coll.transform;
		TotalPointsCount = coll.pointCount;
		points = new Vector2[TotalPointsCount];
		points = coll.points;
		type = CasterType.EdgeCollider2d;
	}
 static public int set_points(IntPtr l)
 {
     UnityEngine.EdgeCollider2D o = (UnityEngine.EdgeCollider2D)checkSelf(l);
     UnityEngine.Vector2[]      v;
     checkType(l, 2, out v);
     o.points = v;
     return(0);
 }
Ejemplo n.º 17
0
 // Use this for initialization
 void Start()
 {
     myRigidBody = GetComponent<Rigidbody2D> ();
     myAnimator = GetComponent<Animator> ();
     myCollider = GetComponent<Collider2D>();
     wallCollider = GetComponent<EdgeCollider2D>();
     player = FindObjectOfType<PlayerController>();
     levelController = FindObjectOfType<LevelController>();
 }
Ejemplo n.º 18
0
 // Use this for initialization
 void Start()
 {
     this.edgeCollider = gameObject.AddComponent<EdgeCollider2D>();
     edgeCollider.sharedMaterial = material;
     this.boxedCamera = gameObject.GetComponent<Camera>();
     float height = 2f * boxedCamera.orthographicSize;
     float width = height * boxedCamera.aspect;
     SetBox(0, 0, width, height);
 }
Ejemplo n.º 19
0
		void OnSelectionChange() {
			if (Selection.gameObjects.Length == 1) {
				EdgeCollider2D aux = Selection.gameObjects[0].GetComponent<EdgeCollider2D>();
				
				if (aux) {
					edge = aux;
					vertices = edge.points;
				}
			}
		}
    void Start()
    {
        terrainList = new List<Vector2>();
        edgeCollider2D = (EdgeCollider2D)this.GetComponent<EdgeCollider2D>().collider2D;

        // Added first two point into the array.
        terrainList.Add(new Vector2(1,1));
        this.AddNextPoint(new Vector2(2,0), 10);
        edgeCollider2D.points = terrainList.ToArray();
    }
    void OnEnable()
    {
        sc = (StarCollider2D)target;

        edgeCollider = sc.GetComponent<EdgeCollider2D>();
        if (edgeCollider == null) {
            sc.gameObject.AddComponent<EdgeCollider2D>();
            edgeCollider = sc.GetComponent<EdgeCollider2D>();
        }
        edgeCollider.points = sc.getPoints(edgeCollider.offset);
    }
 static public int get_edgeCount(IntPtr l)
 {
     try {
         UnityEngine.EdgeCollider2D self = (UnityEngine.EdgeCollider2D)checkSelf(l);
         pushValue(l, self.edgeCount);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
 static public int Reset(IntPtr l)
 {
     try {
         UnityEngine.EdgeCollider2D self = (UnityEngine.EdgeCollider2D)checkSelf(l);
         self.Reset();
         return(0);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
 static public int constructor(IntPtr l)
 {
     try {
         UnityEngine.EdgeCollider2D o;
         o = new UnityEngine.EdgeCollider2D();
         pushValue(l, o);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
	static public int constructor(IntPtr l) {
		try {
			UnityEngine.EdgeCollider2D o;
			o=new UnityEngine.EdgeCollider2D();
			pushValue(l,true);
			pushValue(l,o);
			return 2;
		}
		catch(Exception e) {
			return error(l,e);
		}
	}
Ejemplo n.º 26
0
 static public int get_points(IntPtr l)
 {
     try {
         UnityEngine.EdgeCollider2D self = (UnityEngine.EdgeCollider2D)checkSelf(l);
         pushValue(l, true);
         pushValue(l, self.points);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Ejemplo n.º 27
0
 static public int Reset(IntPtr l)
 {
     try {
         UnityEngine.EdgeCollider2D self = (UnityEngine.EdgeCollider2D)checkSelf(l);
         self.Reset();
         return(0);
     }
     catch (Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return(0);
     }
 }
Ejemplo n.º 28
0
 static public int get_points(IntPtr l)
 {
     try {
         UnityEngine.EdgeCollider2D self = (UnityEngine.EdgeCollider2D)checkSelf(l);
         pushValue(l, self.points);
         return(1);
     }
     catch (Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return(0);
     }
 }
    void OnEnable()
    {
        capCol = (CapsuleCollider2D)target;

        edgeCollider = capCol.GetComponent<EdgeCollider2D>();
        if (edgeCollider == null) {
            capCol.gameObject.AddComponent<EdgeCollider2D>();
            edgeCollider = capCol.GetComponent<EdgeCollider2D>();
        }

        edgeCollider.points = capCol.getPoints(edgeCollider.offset);
    }
    void OnEnable()
    {
        rb = (RoundedBoxCollider2D)target;

        edgeCollider = rb.GetComponent<EdgeCollider2D>();
        if (edgeCollider == null) {
            rb.gameObject.AddComponent<EdgeCollider2D>();
            edgeCollider = rb.GetComponent<EdgeCollider2D>();
        }

        edgeCollider.points = rb.getPoints(edgeCollider.offset);
    }
Ejemplo n.º 31
0
    public void updateMesh()
    {
        mesh = GetComponent<MeshFilter> ().mesh;
        edgeCollider = GetComponent<EdgeCollider2D> ();

        meshBkgFilter = gameObject.transform.Find ("Background").GetComponent<MeshFilter> ();
        meshBkg = meshBkgFilter.mesh;

        float x = 0;
        float y = 0;
        float z = (float) gameObject.transform.position.z;

        if (relativePosition) {
            x = (float) gameObject.transform.position.x;
            y = (float) gameObject.transform.position.y;
        }

        // Use the triangulator to get indices for creating triangles
        Triangulator tr = new Triangulator(vertices);
        int[] indices = tr.Triangulate();

        // Create the Vector3 and collider vertices
        Vector3[] vertices3 = new Vector3[vertices.Length];
        Vector2[] points = new Vector2[vertices.Length];
        for (int i=0; i<vertices.Length; i++) {
            vertices3[i] = new Vector3(x + vertices[i].x, y + vertices[i].y, z);
            points[i] = new Vector2(x + vertices[i].x, y + vertices[i].y);
        }

        Vector2[] uvs = new Vector2[vertices3.Length];
        int i2 = 0;
        while (i2 < uvs.Length) {
            uvs[i2] = new Vector2(vertices3[i2].x, vertices3[i2].z);
            i2++;
        }

        edgeCollider.points = points;

        mesh.vertices = vertices3;
        mesh.triangles = indices;
        mesh.uv = uvs;
        mesh.RecalculateNormals();
        mesh.RecalculateBounds();

        //Background (reverse terrain)
        meshBkg.vertices = vertices3;
        meshBkg.triangles = indices;
        meshBkg.uv = uvs;
        meshBkg.RecalculateNormals();
        meshBkg.RecalculateBounds();
        ReverseNormals (meshBkgFilter);
    }
 static public int set_edgeRadius(IntPtr l)
 {
     try {
         UnityEngine.EdgeCollider2D self = (UnityEngine.EdgeCollider2D)checkSelf(l);
         float v;
         checkType(l, 2, out v);
         self.edgeRadius = v;
         return(0);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
    public void GotoLadderState_FromSpine(EdgeCollider2D ladderSpine)
    {
        // Snap to the ladder
        Vector3 pos = this.transform.position;
        float ladder_x = ladderSpine.points[0].x;
        this.transform.position = new Vector3(ladder_x, pos.y, pos.z);

        SwitchFacingDirection();

        // The platform controller is not active while on a ladder, but our ladder controller is
        this.PlatformController.SetPlayerControllerEnabled(false);
        this.LadderController.SetPlayerControllerEnabled(true);
    }
 public static int constructor(IntPtr l)
 {
     try {
         UnityEngine.EdgeCollider2D o;
         o=new UnityEngine.EdgeCollider2D();
         pushValue(l,o);
         return 1;
     }
     catch(Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return 0;
     }
 }
 static public int set_points(IntPtr l)
 {
     try {
         UnityEngine.EdgeCollider2D self = (UnityEngine.EdgeCollider2D)checkSelf(l);
         UnityEngine.Vector2[]      v;
         checkType(l, 2, out v);
         self.points = v;
         return(0);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Ejemplo n.º 36
0
 static public int constructor(IntPtr l)
 {
     try {
         UnityEngine.EdgeCollider2D o;
         o = new UnityEngine.EdgeCollider2D();
         pushValue(l, o);
         return(1);
     }
     catch (Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return(0);
     }
 }
 static public int constructor(IntPtr l)
 {
     LuaDLL.lua_remove(l, 1);
     UnityEngine.EdgeCollider2D o;
     if (matchType(l, 1))
     {
         o = new UnityEngine.EdgeCollider2D();
         pushObject(l, o);
         return(1);
     }
     LuaDLL.luaL_error(l, "New object failed.");
     return(0);
 }
    // Use this for initialization
    void Start()
    {
        //theBot = GameObject.Find("TheBot");
        //botTrans = theBot.GetComponent<Transform>();

        //botBody = theBot.GetComponent<Rigidbody2D>();
        lineRenderer = GetComponent<LineRenderer>();
        meshRenderer = GetComponent<MeshRenderer>();
        edge = GetComponent<EdgeCollider2D>();


        setUpFill();
        setUpLines();
    }
Ejemplo n.º 39
0
	/// <summary>
	/// Creates the circle.
	/// </summary>
	void CreateCircle()
	{
		Vector2[] edgePoints = new Vector2[NumPoints + 1];
		EdgeCollider = GetComponent<EdgeCollider2D>();

		for(int loop = 0; loop <= NumPoints; loop++)
		{
			float angle = (Mathf.PI * 2.0f / NumPoints) * loop;
			edgePoints[loop] = new Vector2(Mathf.Sin(angle), Mathf.Cos(angle)) * Radius;
		}

		EdgeCollider.points = edgePoints;
		CurrentRadius = Radius;
	}
    public void GotoLadderState_FromTop(EdgeCollider2D ladderSpine)
    {
        // We need to snap to the ladder plus move down past the ladder top so we don't collide with it
        // (We take for granted that the edge collider points for the spine go from down-to-up)
        Vector3 pos = this.transform.position;
        float ladder_x = ladderSpine.points[0].x;
        float ladder_y = ladderSpine.points[1].y;
        this.transform.position = new Vector3(ladder_x, ladder_y - 2.0f, pos.z);

        SwitchFacingDirection();

        // The platform controller is not active while on a ladder, but our ladder controller is
        this.PlatformController.SetPlayerControllerEnabled(false);
        this.LadderController.SetPlayerControllerEnabled(true);
    }
Ejemplo n.º 41
0
 /// <summary>
 /// Write the specified value using the writer.
 /// </summary>
 /// <param name="value">Value.</param>
 /// <param name="writer">Writer.</param>
 public override void Write(object value, ISaveGameWriter writer)
 {
     UnityEngine.EdgeCollider2D edgeCollider2D = (UnityEngine.EdgeCollider2D)value;
     writer.WriteProperty("edgeRadius", edgeCollider2D.edgeRadius);
     writer.WriteProperty("points", edgeCollider2D.points);
     writer.WriteProperty("density", edgeCollider2D.density);
     writer.WriteProperty("isTrigger", edgeCollider2D.isTrigger);
     writer.WriteProperty("usedByEffector", edgeCollider2D.usedByEffector);
     writer.WriteProperty("usedByComposite", edgeCollider2D.usedByComposite);
     writer.WriteProperty("offset", edgeCollider2D.offset);
     writer.WriteProperty("sharedMaterial", edgeCollider2D.sharedMaterial);
     writer.WriteProperty("enabled", edgeCollider2D.enabled);
     writer.WriteProperty("tag", edgeCollider2D.tag);
     writer.WriteProperty("name", edgeCollider2D.name);
     writer.WriteProperty("hideFlags", edgeCollider2D.hideFlags);
 }
Ejemplo n.º 42
0
    void OnGUI()
    {
        GUILayout.Label ("EdgeCollider2D point editor", EditorStyles.boldLabel);
        edge = (EdgeCollider2D) EditorGUILayout.ObjectField("EdgeCollider2D to edit", edge, typeof(EdgeCollider2D), true);
        if (vertices.Length != 0) {
            for (int i = 0; i < vertices.Length; ++i) {
                vertices[i] = (Vector2) EditorGUILayout.Vector2Field("Element "+i, vertices[i]);
            }
        }

        if (GUILayout.Button ("Retrieve")) {
            vertices = edge.points;
        }

        if (GUILayout.Button ("Set")) {
            edge.points = vertices;
        }
    }
Ejemplo n.º 43
0
    void startFigur(int kolStor,int chAngle)
    {
        float _var=2f;
        float Angle=360;
        Angle = Angle * Mathf.Deg2Rad;
        float checkAngle=Angle/kolStor;
        //PolygonCollider2D poligon = gameObject.AddComponent<PolygonCollider2D>();
        position = new Vector2[kolStor + 1];
        line = transform.GetComponent<LineRenderer>();
        line.SetVertexCount(kolStor+1);
        for (int i = 0; i < kolStor+1; i++)
        {
            position[i] = new Vector2(Mathf.Cos(checkAngle * i - chAngle * Mathf.Deg2Rad) * _var, Mathf.Sin(checkAngle * i - chAngle * Mathf.Deg2Rad) * _var);
            line.SetPosition(i, new Vector3(Mathf.Cos(checkAngle * i - chAngle * Mathf.Deg2Rad) * _var, Mathf.Sin(checkAngle * i - chAngle * Mathf.Deg2Rad) * _var, 0));
        }

        line.SetPosition(kolStor, position[0]);
        coll = gameObject.AddComponent<EdgeCollider2D>();
        coll.points = position;
    }
  //------------------------------------------------------------------------------------------------
  // Creates the inner and outer circular collider
  void DrawCircle()
  {
    Vector2[] edgePoints = new Vector2[NumPoints + 2];
    EdgeCollider = GetComponent<EdgeCollider2D>();

    for(int loop = 0; loop <= NumPoints / 2; loop++)
    {
      float angle = (Mathf.PI * 2.0f / NumPoints) * loop * 2;
      edgePoints[loop] = new Vector2(Mathf.Sin(angle), Mathf.Cos(angle)) * InnerRadius;
    }

    for(int loop = NumPoints / 2 + 1; loop <= NumPoints + 1; loop++)
    {
      float angle = (Mathf.PI * 2.0f / NumPoints) * loop * 2;
      edgePoints[loop] = new Vector2(-Mathf.Sin(angle), Mathf.Cos(angle)) * (OuterRadius);
    }
    EdgeCollider.points = edgePoints;
    CurrentInner = InnerRadius;
    CurrentOuter = OuterRadius;
  }
Ejemplo n.º 45
0
        private static void AddEdgeCollider2DSegments(List<Segment> segments, EdgeCollider2D collider)
        {
            if (collider.points.Length < 2)
            {
                return;
            }

            List<Vector2> transformed =
                collider
                    .points
                    .Select(p => (Vector2)collider.transform.TransformPoint(p + collider.offset))
                    .ToList();

            for (int index = 0; index < transformed.Count - 1; index++)
            {
                segments.Add(
                    new Segment(
                        transformed[index],
                        transformed[index + 1]));
            }
        }
Ejemplo n.º 46
0
    // Use this for initialization
    void Awake()
    {
        // find son objs
        foreach (Transform trans in this.transform) {
            if (trans.gameObject.name == "hand")
                hand = trans.gameObject;
            else
                light = trans.gameObject;
            Debug.Log("name" + trans.gameObject.name);
        }
        // set transform
        handcolor = hand.GetComponent<SpriteRenderer> ().color;
        handcolor.a = 0;
        hand.GetComponent<SpriteRenderer> ().color = handcolor;

        lightcolor = light.GetComponent<SpriteRenderer> ().color;
        lightcolor.a = 0;
        light.GetComponent<SpriteRenderer> ().color = lightcolor;

        _edgeCollider = hand.GetComponent<EdgeCollider2D>();
    }
Ejemplo n.º 47
0
        /// <summary>
        /// Read the data into the specified value.
        /// </summary>
        /// <param name="value">Value.</param>
        /// <param name="reader">Reader.</param>
        public override void ReadInto(object value, ISaveGameReader reader)
        {
            UnityEngine.EdgeCollider2D edgeCollider2D = (UnityEngine.EdgeCollider2D)value;
            foreach (string property in reader.Properties)
            {
                switch (property)
                {
                case "edgeRadius":
                    edgeCollider2D.edgeRadius = reader.ReadProperty <System.Single> ();
                    break;

                case "points":
                    edgeCollider2D.points = reader.ReadProperty <UnityEngine.Vector2[]> ();
                    break;

                case "density":
                    edgeCollider2D.density = reader.ReadProperty <System.Single> ();
                    break;

                case "isTrigger":
                    edgeCollider2D.isTrigger = reader.ReadProperty <System.Boolean> ();
                    break;

                case "usedByEffector":
                    edgeCollider2D.usedByEffector = reader.ReadProperty <System.Boolean> ();
                    break;

                case "usedByComposite":
                    edgeCollider2D.usedByComposite = reader.ReadProperty <System.Boolean> ();
                    break;

                case "offset":
                    edgeCollider2D.offset = reader.ReadProperty <UnityEngine.Vector2> ();
                    break;

                case "sharedMaterial":
                    if (edgeCollider2D.sharedMaterial == null)
                    {
                        edgeCollider2D.sharedMaterial = reader.ReadProperty <UnityEngine.PhysicsMaterial2D> ();
                    }
                    else
                    {
                        reader.ReadIntoProperty <UnityEngine.PhysicsMaterial2D> (edgeCollider2D.sharedMaterial);
                    }
                    break;

                case "enabled":
                    edgeCollider2D.enabled = reader.ReadProperty <System.Boolean> ();
                    break;

                case "tag":
                    edgeCollider2D.tag = reader.ReadProperty <System.String> ();
                    break;

                case "name":
                    edgeCollider2D.name = reader.ReadProperty <System.String> ();
                    break;

                case "hideFlags":
                    edgeCollider2D.hideFlags = reader.ReadProperty <UnityEngine.HideFlags> ();
                    break;
                }
            }
        }
 static public int get_points(IntPtr l)
 {
     UnityEngine.EdgeCollider2D o = (UnityEngine.EdgeCollider2D)checkSelf(l);
     pushValue(l, o.points);
     return(1);
 }
Ejemplo n.º 49
0
 /// <summary>
 /// Read the data using the reader.
 /// </summary>
 /// <param name="reader">Reader.</param>
 public override object Read(ISaveGameReader reader)
 {
     UnityEngine.EdgeCollider2D edgeCollider2D = SaveGameType.CreateComponent <UnityEngine.EdgeCollider2D> ();
     ReadInto(edgeCollider2D, reader);
     return(edgeCollider2D);
 }