Collider for 2D physics representing an arbitrary set of connected edges (lines) defined by its vertices.
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(); }
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; } }
void Awake() { edgeCollider = GetComponent<EdgeCollider2D>(); thisCamera = Camera.main; lineRenderer = GetComponent<LineRenderer>(); }
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; } }
void Start() { edgeCollider = GetComponent<EdgeCollider2D>(); mesh = GetComponent<MeshFilter>().mesh; SetupVerts(); }
void OnDrawGizmos() { edge = GetComponent<EdgeCollider2D>(); min = edge.bounds.min; max = edge.bounds.max; Gizmos.color = Color.yellow; Gizmos.DrawLine(min, max); }
static public int constructor(IntPtr l) { UnityEngine.EdgeCollider2D o; o = new UnityEngine.EdgeCollider2D(); pushObject(l, o); return(1); }
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 }
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)); }
// 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]); }
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; }
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); }
// Use this for initialization void Start() { myRigidBody = GetComponent<Rigidbody2D> (); myAnimator = GetComponent<Animator> (); myCollider = GetComponent<Collider2D>(); wallCollider = GetComponent<EdgeCollider2D>(); player = FindObjectOfType<PlayerController>(); levelController = FindObjectOfType<LevelController>(); }
// 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); }
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); } }
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)); } }
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); } }
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); }
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)); } }
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(); }
/// <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); }
/// <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); }
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; } }
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; }
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])); } }
// 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>(); }
/// <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); }
/// <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); }