public void AttachToCat(StackableCat previous) { _hinge = previous.gameObject.AddComponent <HingeJoint2D>(); _hinge.useLimits = true; var rotationOffset = -previous.transform.eulerAngles.z; var limits = new JointAngleLimits2D { min = (-135f + rotationOffset + 360f) % 360f, max = (-45f + rotationOffset + 360f) % 360f }; _hinge.limits = limits; _hinge.connectedBody = _rigidBody; var motor = new JointMotor2D { motorSpeed = 10, maxMotorTorque = 10000 }; _hinge.motor = motor; _hinge.useMotor = true; _distance = previous.gameObject.AddComponent <DistanceJoint2D>(); _distance.autoConfigureDistance = false; _distance.distance = 2.5f; _distance.connectedBody = _rigidBody; _rigidBody.bodyType = RigidbodyType2D.Dynamic; _rigidBody.simulated = true; }
void Awake() { gameStop = false; _tr = transform; whenKick_State_1 = scr.bonObjMan.whenKick_State_1_Norm; enSprTr = enSpr.transform; kickSpeed = scr.pMov.kickSpeed0; if (_enType != OpponentType.Goalkeeper) { _enType = scr.buf.oppType; enSpr.sprite = scr.buf.enSpr; maxSpeed = scr.pMov.maxSpeed0 * scr.buf.enSkillSpeed / 100f; jumpForce = scr.pMov.jumpForce0 * scr.buf.enSkillJump / 100f; kickTorque = scr.pMov.kickTorque0 * scr.buf.enSkillKick / 100f; } else { enSpr.sprite = scr.buf.enSpr_1; maxSpeed = scr.pMov.maxSpeed0 * scr.buf.enSkillSpeed_1 / 100f; jumpForce = scr.pMov.jumpForce0 * scr.buf.enSkillJump_1 / 100f; kickTorque = scr.pMov.kickTorque0 * scr.buf.enSkillKick_1 / 100f; } SKJ_Upgrades(); jumpForceDef = jumpForce; JointAngleLimits2D limits = legHJ.limits; JointMotor2D motor = legHJ.motor; legHJ.limits = limits; motor.maxMotorTorque = 0; legHJ.motor = motor; }
void Awake() { rb = GetComponent <Rigidbody2D>(); myRagdoll = GetComponentInParent <RagdollManager>(); footStartXRight = RightFoot.transform.localPosition.x; footStartXLeft = LeftFoot.transform.localPosition.x; rightLegLimits = RightLeg.limits; leftLegLimits = LeftLeg.limits; rightArmLimits = RightArm.limits; leftArmLimits = LeftArm.limits; //Player Specific Movement added by Kate if (transform.parent.CompareTag("PlayerOne")) { playerInt = 1; } else if (transform.parent.CompareTag("PlayerTwo")) { playerInt = 2; } if (playerInt < 1) { throw new SystemException("Player Missing Correct Tag: " + transform.name); } //Gun Control added by Kate gunLocation = gunLocationRight.transform; }
void Awake() { rb = GetComponent <Rigidbody2D>(); foot = GetComponentInChildren <HingeJoint2D>(); t = GetComponent <Transform>(); initialPos = t.position; initialScale = t.localScale; m = foot.motor; m.maxMotorTorque = kickMaxMotorForce; // Change the side of the foot, depending on the direction the player is facing JointAngleLimits2D limits = foot.limits; if (facing == Direction.Right) { limits.min = -15; limits.max = 105; foot.limits = limits; } else { limits.min = 195; limits.max = 75; foot.limits = limits; } }
// слипание клеток public void Link(Cell cell) { if (links.ContainsKey(cell)) { return; } if (links.Keys.Count > 5) { return; } if (cell.links.Keys.Count > 5) { return; } HingeJoint2D joint = gameObject.AddComponent <HingeJoint2D>(); joint.connectedBody = cell.gameObject.GetComponent <Rigidbody2D>(); joint.useLimits = true; JointAngleLimits2D limits = new JointAngleLimits2D { min = -15, max = 15 }; joint.limits = limits; joint.breakForce = 20f; joint.breakTorque = 20f; links.Add(cell, joint); cell.links.Add(this, joint); }
void AttachToNewPiece() { GameObject prevPiece = pieces[1]; GameObject newPiece = pieces[0]; HingeJoint2D joint = prevPiece.AddComponent <HingeJoint2D>(); joint.connectedBody = newPiece.GetComponent <Rigidbody2D>(); JointAngleLimits2D limits = joint.limits; limits.min = 0; limits.max = 90; joint.limits = limits; joint.useLimits = true; DistanceJoint2D distance = prevPiece.AddComponent <DistanceJoint2D>(); distance.connectedBody = newPiece.GetComponent <Rigidbody2D>(); distance.maxDistanceOnly = true; FixedJoint2D fixedJoint = newPiece.AddComponent <FixedJoint2D>(); fixedJoint.connectedBody = ropeBase; ropeBase.transform.Translate(0, -0.5f, 0); Invoke("AddPiece", 0.1f); }
void CreateAllLinks(Rigidbody2D[] parents) { List <Rigidbody2D> newParents = new List <Rigidbody2D>(); Rigidbody2D rigidbodyTemp; _jointLimit = new JointAngleLimits2D(); _jointLimit.min = -_angleLimit * 0.5f; _jointLimit.max = _angleLimit * 0.5f; for (int i = 0; i < parents.Length; i++) { for (int j = 0; j < parents[i].transform.childCount; j++) { if (!IsExclude(parents[i].transform.GetChild(j))) { rigidbodyTemp = parents[i].transform.GetChild(j).gameObject.AddComponent <Rigidbody2D>(); if (parents[i].transform.GetChild(j).childCount > 0) { newParents.Add(rigidbodyTemp); } _links.Add(new Link(rigidbodyTemp, parents[i], _jointLimit)); } } } if (newParents.Count > 0) { CreateAllLinks(newParents.ToArray()); } newParents.Clear(); }
public static void increaseLength() { leadermovement.ForwardForce += 0.6f; leadermovement.RotationSpeed += 7; applyDiminishingDrag(); List <GameObject> templist = convoylist1.getVehicles(); int size = convoylist1.getVehicles().Count; Vector2 pos = templist[size - 1].transform.position - templist[size - 1].transform.up; Quaternion rot = templist[size - 1].transform.rotation; //pos = pos-new Vector3(0,-1,0); GameObject tempobj = Instantiate(Resources.Load("prefabs/bodySection"), pos, rot) as GameObject; //Instantiate(Resources.Load("PrefabName"), position, rotation) tempobj.tag = "body"; HingeJoint2D hj = templist[size - 1].AddComponent <HingeJoint2D>() as HingeJoint2D; hj.anchor = new Vector2(0, -1); hj.useLimits = true; JointAngleLimits2D lims = hj.limits; lims.min = -45; lims.max = 45; hj.limits = lims; templist[size - 1].GetComponent <HingeJoint2D>().connectedBody = tempobj.GetComponent <Rigidbody2D>(); //tempobj.transform.localScale = new Vector3(1,1,1); //OTAnimatingSprite otscript = tempobj.GetComponent<OTAnimatingSprite>(); //otscript.size.X = 1; //otscript.size.Y = 1; convoylist1.getVehicles().Add(tempobj); }
public static void ReadHingeJoint2D(this BinaryReader reader, HingeJoint2D joint) { byte flags = reader.ReadByte(); joint.enabled = (flags & 0x01) > 0; joint.anchor = reader.ReadVector2(); joint.connectedAnchor = reader.ReadVector2() + (Vector2)joint.transform.position; if ((flags & 0x02) > 0) { joint.useMotor = true; JointMotor2D motor = joint.motor; motor.motorSpeed = reader.ReadSingle(); motor.maxMotorTorque = reader.ReadSingle(); joint.motor = motor; } else { joint.useMotor = false; } if ((flags & 0x04) > 0) { joint.useLimits = true; JointAngleLimits2D limits = joint.limits; limits.min = reader.ReadSingle(); limits.max = reader.ReadSingle(); joint.limits = limits; } else { joint.useLimits = false; } }
void Start() { _activeLimits = new JointAngleLimits2D { min = Flip ? 90 : -90, max = 0 }; _passiveLimits = new JointAngleLimits2D { min = 0, max = 0 }; _joint = GetComponent <HingeJoint2D>(); if (IsActive) { _joint.limits = _activeLimits; _motorHit = new JointMotor2D(); _motorHit.motorSpeed = Flip ? MotorSpeed : -MotorSpeed; _motorHit.maxMotorTorque = MaxMotorTorque; _motorIdle = new JointMotor2D(); _motorIdle.motorSpeed = Flip ? -MotorSpeed : MotorSpeed;; _motorIdle.maxMotorTorque = MaxMotorTorque; } else { _joint.limits = _passiveLimits; _motorHit = new JointMotor2D(); _motorHit.motorSpeed = MotorSpeed; _motorHit.maxMotorTorque = MaxMotorTorque; _motorIdle = new JointMotor2D(); _motorIdle.motorSpeed = -MotorSpeed; _motorIdle.maxMotorTorque = MaxMotorTorque; } }
// Update is called once per frame void Update() { if (!settedMinMax) { settedMinMax = true; JointAngleLimits2D newLimits = hinge.limits; newLimits.min = minMax.x; newLimits.max = minMax.y; hinge.limits = newLimits; } if (hinge.jointAngle >= hinge.limits.max) { JointMotor2D newMotor = hinge.motor; newMotor.motorSpeed = -Mathf.Abs(newMotor.motorSpeed); hinge.motor = newMotor; JointAngleLimits2D newLimits = hinge.limits; newLimits.min = -Random.Range(0f, 60f); hinge.limits = newLimits; } else if (hinge.jointAngle <= hinge.limits.min) { JointMotor2D newMotor = hinge.motor; newMotor.motorSpeed = Mathf.Abs(newMotor.motorSpeed); hinge.motor = newMotor; JointAngleLimits2D newLimits = hinge.limits; newLimits.max = Random.Range(0f, 60f); hinge.limits = newLimits; } }
// Update is called once per frame private void FixedUpdate() { Rigidbody2D connectedBody = hj2D.connectedBody; //필요 없으나 에디터 뷰에서 정확한 움직임 확인 가능 if (degMax != hj2D.limits.max) { JointAngleLimits2D limit = hj2D.limits; limit.max = degMax; limit.min = -degMax; hj2D.limits = limit; } if (Mathf.Abs(connectedBody.rotation) >= degMax) { dir = -(int)Mathf.Sign(connectedBody.rotation); hj2D.connectedBody.rotation = degMax * (-dir); } JointMotor2D motor = hj2D.motor; float percentOfSwing = lean * (-Mathf.Pow(connectedBody.rotation / degMax, 2) + 1.1f); float spd = dir * motorSpeed * percentOfSwing; motor.motorSpeed = spd; hj2D.motor = motor; }
HingeJoint2D CreateJoint(BoneBridgeSnapToSocket socket, float lowerAngle, float upperAngle, float anchorOffset) { if (GetComponent <Rigidbody2D> ()) { boneJoint = gameObject.AddComponent <HingeJoint2D> (); } else { boneJoint = transform.parent.gameObject.AddComponent <HingeJoint2D> (); boneJoint.anchor = new Vector2(anchorOffset, boneJoint.anchor.y); } socket.GetComponent <BoneBridgeJoint> ().boneJoint = boneJoint; Rigidbody2D rigBody = socket.transform.parent.GetComponent <Rigidbody2D> (); rigBody.velocity = Vector2.zero; boneJoint.breakForce = jointBreakForce; boneJoint.connectedBody = rigBody; JointAngleLimits2D limits = boneJoint.limits; limits.min = lowerAngle; limits.max = upperAngle; boneJoint.limits = limits; boneJoint.useLimits = true; return(boneJoint); }
public void EnableLock(bool enable) { if (!enabled) { angleLocker.enabled = false; return; } JointAngleLimits2D limits = angleLocker.limits; switch (difficulty) { case Difficulty.Easy: angleLocker.enabled = true; limits.min = -easyLockAngle; limits.max = easyLockAngle; break; case Difficulty.Medium: angleLocker.enabled = true; limits.min = -mediumLockAngle; limits.max = mediumLockAngle; break; case Difficulty.Hard: angleLocker.enabled = false; break; } angleLocker.limits = limits; }
// Update is called once per frame void Update() //I'm using Update rather than FixedUpdate because when I tried FixedUpdate, GetKeyDown was calling the interact key twice rather than once. And at that point what the f**k is the point of using GetKeyDown? { if (Input.GetKeyDown(interact)) { Debug.Log("You pressed E"); if (isOpenable == true && isOpen == false) //This opens the door { HingeJoint2D hinge = gameObject.GetComponent(typeof(HingeJoint2D)) as HingeJoint2D; //locally initializing our 2D Hinge Point rb.constraints = RigidbodyConstraints2D.None; //Removing the rotation constraints placed on the door originally hinge.enabled = true; //Enabling our HingeJoint2D isOpen = true; //Setting this bool to true tells us this door is open. Door.GetComponent <BoxCollider2D>().enabled = false; } else if (isOpenable == true && isOpen == true) { HingeJoint2D hinge = gameObject.GetComponent(typeof(HingeJoint2D)) as HingeJoint2D; JointMotor2D motor = hinge.motor; motor.motorSpeed = -motor.motorSpeed; hinge.motor = motor; JointAngleLimits2D limits = this.gameObject.GetComponent <HingeJoint2D>().limits; limits.min = limits.min + 90; limits.max = limits.max; this.gameObject.GetComponent <HingeJoint2D>().limits = limits; //This commented shit is what I want to do once the door is not moving and in the closed position. //isOpen = false; //Door.GetComponent<BoxCollider2D>().enabled = true; //rb.constraints = RigidbodyConstraints2D.FreezeAll; //JointAngleLimits2D limits = this.gameObject.GetComponent<HingeJoint2D>().limits; //limits.min = limits.min - 90; //this.gameObject.GetComponent<HingeJoint2D>().limits = limits; } } }
//\this being here will save GC allocs // Use this for initialization void Start() { _joint = (HingeJoint2D)gameObject.GetComponent("HingeJoint2D"); _joint.connectedAnchor = transform.TransformPoint(_joint.anchor); _default_limits = _joint.limits; _stop_limits.min = 0f; _stop_limits.max = 0f; }
public void Start() { JointAngleLimits2D limits = joint.limits; limits.min = joint.limits.max; limits.max = joint.limits.min; joint.limits = limits; }
// Set min and max angle hinge can turn to public void setLimits(float min, float max) { JointAngleLimits2D limits = hinge.limits; limits.max = max; limits.min = min; hinge.limits = limits; }
static int _CreateJointAngleLimits2D(IntPtr L) { LuaScriptMgr.CheckArgsCount(L, 0); JointAngleLimits2D obj = new JointAngleLimits2D(); LuaScriptMgr.PushValue(L, obj); return(1); }
public JointAngleLimits2D ToJointAngleLimits2D() { JointAngleLimits2D limits = new JointAngleLimits2D(); limits.min = min; limits.max = max; return(limits); }
/// <summary> /// 同组的成员销毁 /// </summary> public void GroupMemberDestroy() { JointAngleLimits2D jointAngleLimits2D = new JointAngleLimits2D { min = -180, max = 180 }; hingeJoint2D.limits = jointAngleLimits2D; //重新设置一下旋转角度 }
private void Awake() { hingeJoint2D = transform.Find("Hinge").GetComponent <HingeJoint2D>(); openDoorLimits = hingeJoint2D.limits; closeDoorLimits = new JointAngleLimits2D { min = 0f, max = 0f }; CloseDoor(); }
void useLimit() { joint2D.useLimits = true; JointAngleLimits2D limit = joint2D.limits; limit.max = joint2D.jointAngle; limit.min = joint2D.jointAngle; joint2D.limits = limit; }
private void SetHingeLimits() { var limits = new JointAngleLimits2D(); float angleLimit = 5 + (175 * (Mathf.Abs(_hingeJoint.transform.localPosition.x) / _runnerLength)); limits.max = -angleLimit; limits.min = angleLimit; _hingeJoint.limits = limits; }
public new void OnSceneGUI() { HingeJoint2D hingeJoint2D = (HingeJoint2D)base.target; if (hingeJoint2D.enabled) { this.m_AngularLimitHandle.xMotion = ((!hingeJoint2D.useLimits) ? ConfigurableJointMotion.Free : ConfigurableJointMotion.Limited); JointAngleLimits2D limits = hingeJoint2D.limits; this.m_AngularLimitHandle.xMin = limits.min; this.m_AngularLimitHandle.xMax = limits.max; bool flag = EditMode.editMode == EditMode.SceneViewEditMode.JointAngularLimits && EditMode.IsOwner(this); if (flag) { this.m_AngularLimitHandle.angleHandleDrawFunction = null; } else { this.m_AngularLimitHandle.angleHandleDrawFunction = new Handles.CapFunction(this.NonEditableHandleDrawFunction); } Rigidbody2D rigidbody2D = hingeJoint2D.attachedRigidbody; Vector3 point = Vector3.right; Vector2 v = hingeJoint2D.anchor; Rigidbody2D rigidbody2D2 = hingeJoint2D.connectedBody; Quaternion rhs = HingeJoint2DEditor.s_RightHandedHandleOrientationOffset; if (rigidbody2D.bodyType != RigidbodyType2D.Dynamic && hingeJoint2D.connectedBody != null && hingeJoint2D.connectedBody.bodyType == RigidbodyType2D.Dynamic) { rigidbody2D = hingeJoint2D.connectedBody; point = Vector3.left; v = hingeJoint2D.connectedAnchor; rigidbody2D2 = hingeJoint2D.attachedRigidbody; rhs = HingeJoint2DEditor.s_LeftHandedHandleOrientationOffset; } Vector3 vector = Joint2DEditor.TransformPoint(rigidbody2D.transform, v); Quaternion q = ((!(rigidbody2D2 == null)) ? Quaternion.LookRotation(Vector3.forward, rigidbody2D2.transform.rotation * Vector3.up) : Quaternion.identity) * rhs; Vector3 point2 = vector + Quaternion.LookRotation(Vector3.forward, rigidbody2D.transform.rotation * Vector3.up) * point; Matrix4x4 matrix = Matrix4x4.TRS(vector, q, Vector3.one); EditorGUI.BeginChangeCheck(); using (new Handles.DrawingScope(HingeJoint2DEditor.Styles.handleColor, matrix)) { float num = HandleUtility.GetHandleSize(Vector3.zero) * HingeJoint2DEditor.Styles.handleRadius; this.m_AngularLimitHandle.radius = num; Handles.DrawLine(Vector3.zero, matrix.inverse.MultiplyPoint3x4(point2).normalized *num); this.m_AngularLimitHandle.DrawHandle(); } if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(hingeJoint2D, HingeJoint2DEditor.Styles.editAngularLimitsUndoMessage); limits = hingeJoint2D.limits; limits.min = this.m_AngularLimitHandle.xMin; limits.max = this.m_AngularLimitHandle.xMax; hingeJoint2D.limits = limits; rigidbody2D.WakeUp(); } base.OnSceneGUI(); } }
void InitialisePlayerTank() { tankRigidBody = GameObject.Find("NavyTankBase").GetComponent <Rigidbody2D>(); barrelHinge = gameObject.AddComponent <HingeJoint2D>(); JointAngleLimits2D jointLimits = barrelHinge.limits; barrelHinge.connectedBody = tankRigidBody; barrelHinge.autoConfigureConnectedAnchor = true; }
protected void SetJointLimit(float upper, float lower) { JointAngleLimits2D temp = new JointAngleLimits2D { max = upper, min = lower }; _bodyJoint.limits = temp; }
protected override void Awake() { base.Awake(); hj = GetComponent <HingeJoint2D>(); rb = GetComponent <Rigidbody2D>(); JointAngleLimits2D ja = new JointAngleLimits2D(); ja.max = maxAngle; ja.min = minAngle; hj.limits = ja; }
void Start() { hingeJoint1 = gameObject.GetComponent <HingeJoint2D>(); jointMotor = hingeJoint1.motor; JointAngleLimits2D limits = hingeJoint1.limits; limits.min = -30; limits.max = 30; hingeJoint1.limits = limits; hingeJoint1.useLimits = true; }
// Use this for initialization void Start() { minMax = new Vector2(hinge.limits.min, hinge.limits.max); float rand = Random.Range(hinge.limits.min, hinge.limits.max); JointAngleLimits2D newLimits = hinge.limits; newLimits.min = rand; newLimits.max = rand; hinge.limits = newLimits; }