C# UnityEngine.Collision类代码示例

 void OnCollisionEnter(Collision col)
 {
     var weHit = col.gameObject;
     if(weHit.tag.Equals("Pickupable")) {
         weHit.transform.position = new Vector3(weHit.transform.position.x, 100, weHit.transform.position.z);
     }
 }

 void OnCollisionEnter(Collision col)
 {
     if (col.gameObject.tag.Equals(tagType)) {
         Destroy(col.gameObject);
         Destroy(gameObject);
     }
 }

				void OnCollisionEnter (Collision collision)
				{
						if (TargetValidator != null && !TargetValidator.Test (collision.gameObject))
								return;

						BoolValue = true;
				}

 void OnCollisionStay(Collision collision)
 {
     if (collision.gameObject && collision.gameObject.tag == "Hero")
     {
         eventCollistionStayHero(this, collision.gameObject.GetComponent<Hero>());
     }
 }

 void OnCollisionEnter(Collision collision)
 {
     Utils.Log("Collision detected with {0}", collision.gameObject.name);
     Utils.Log("Collider is {0}", collision.collider);
     foreach(ContactPoint c in collision.contacts)
     {
         Utils.Log("Contact point: this collider {0}; other collider {1}", c.thisCollider, c.otherCollider);
         Utils.Log("other collider tag: {0}", c.otherCollider.tag);
         Utils.Log("Other pmat: bounce {0}, dynFric {1}, statFric {2}",
             c.otherCollider.material.bounciness,
             c.otherCollider.material.dynamicFriction,
             c.otherCollider.material.staticFriction);
         Utils.Log("Other pmat: bounce-comb {0}, Fric-comb {1}, dynFric2 {2}, statFric2 {3}, FricDir2 {4}",
             c.otherCollider.material.bounceCombine,
             c.otherCollider.material.frictionCombine,
             c.otherCollider.material.dynamicFriction2,
             c.otherCollider.material.staticFriction2,
             c.otherCollider.material.frictionDirection2);
         foreach(Wheel w in wheels)
         {
             Utils.Log("Wheel {0}", w.wheelName);
             Utils.Log("forwardFriction.stiffness {0}, sidewaysFriction.stiffness {1}",
                 w.whCollider.forwardFriction.stiffness, w.whCollider.sidewaysFriction.stiffness);
             Utils.Log("forwardFriction.asymptote {0}, sidewaysFriction.asymptote {1}",
                 w.whCollider.forwardFriction.asymptoteValue, w.whCollider.sidewaysFriction.asymptoteValue);
             Utils.Log("forwardFriction.a-slip {0}, sidewaysFriction.a-slip {1}",
                 w.whCollider.forwardFriction.asymptoteSlip, w.whCollider.sidewaysFriction.asymptoteSlip);
             Utils.Log("forwardFriction.extremum {0}, sidewaysFriction.extremum {1}",
                 w.whCollider.forwardFriction.extremumValue, w.whCollider.sidewaysFriction.extremumValue);
             Utils.Log("forwardFriction.e-slip {0}, sidewaysFriction.e-slip {1}",
                 w.whCollider.forwardFriction.extremumSlip, w.whCollider.sidewaysFriction.extremumSlip);
         }
     }
 }

 public override void OnCollisionExit(Collision collision)
 {
     if (string.IsNullOrEmpty(tag.Value) || tag.Value.Equals(collision.gameObject.tag)) {
         collidedGameObject.Value = collision.gameObject;
         exitedCollision = true;
     }
 }

 void OnCollisionStay(Collision aCollision)
 {
     if(m_Character != null)
     {
     m_Character.OnCollisionStay(aCollision);
     }
 }

 public override void DoCollisionStay(Collision collisionInfo)
 {
     if (this.runFsm.HandleCollisionStay)
     {
         this.runFsm.OnCollisionStay(collisionInfo);
     }
 }

		// Re-enable fixed time step smoothing on the characters that exited this platform
		void OnCollisionExit(Collision collision) {
			if (collision.gameObject.layer == characterLayer) {
				CharacterThirdPerson c = collision.gameObject.GetComponent<CharacterThirdPerson>();
				if (c == null) return;
				c.smoothPhysics = true;
			}
		}

 public CollisionNodeInfo(CollisionNodeToggler hitNode, Collider colliderObj, Collision collisionObj, ControllerColliderHit cchit)
 {
     this.hitNode = hitNode;
     collider = colliderObj;
     collision = collisionObj;
     controllerColliderHit = cchit;
 }

 public override void DoCollisionExit(Collision collisionInfo)
 {
     if (this.runFsm.HandleCollisionExit)
     {
         this.runFsm.OnCollisionExit(collisionInfo);
     }
 }

 void OnCollisionEnter(Collision col)
 {
     if (col.gameObject == destroyGoal)
     {
         Destroy(gameObject);
     }
 }

 void OnCollisionEnter(Collision coll)
 {
     if(coll.collider.tag == "Player" && !Pressed && !done)
     {
         Press();
     }
 }

 public override void DoCollisionEnter(Collision collisionInfo)
 {
     if (runFsm.HandleCollisionEnter)
     {
         runFsm.OnCollisionEnter(collisionInfo);
     }
 }

        private void OnCollisionEnter(Collision col)
        {
            if (col.contacts.Length > 0)
            {
                _impactBody = col.rigidbody;
                _impactMass = (col.rigidbody != null) ? col.rigidbody.mass : 1.0f;
                _impactVelocity = col.relativeVelocity;

                Rigidbody rb = GetComponent<Rigidbody>();
                if (rb != null)
                {
                    // Always have the impact velocity point in our moving direction
                    _impactVelocity *= Mathf.Sign(Vector3.Dot(rb.velocity, _impactVelocity));
                }

                float mag = _impactVelocity.magnitude;
                Vector3 force = 0.5f * _impactMass * _impactVelocity * mag;

                if ((ForceThreshold * ForceThreshold) <=
                    force.sqrMagnitude)
                {
                    _impactPoint = Vector3.zero;

                    for (int i = 0; i < col.contacts.Length; i++)
                    {
                        _impactPoint += col.contacts[i].point;
                    }
                    _impactPoint *= 1.0f / col.contacts.Length;

                    Vector3 localPoint = transform.worldToLocalMatrix.MultiplyPoint(_impactPoint);

                    GetComponent<FractureGeometry>().Fracture(localPoint);
                }
            }
        }