//Raugh version
 void OnCollisionEnter(Collision collision)
 {
     foreach (ContactPoint contact in collision.contacts) {
         finalContact = contact;
     }
     collision.rigidbody.AddForce(finalContact.normal * bouncyness);
 }

    /* we need to determine what direction we collided with environment so we can change direction.
     * we check first and last point in the collection and determine what pieces of the vector positions match
     * and then flip horizontal/vertical while maintaining the opposite movement (vertical/horizontal respectively)
     */
    void SwitchDirection(ContactPoint[] hits)
    {
        // InverseTransformPoint will convert to local space so we can easily tell where it is in relation to us
        Vector3 relativePosition1 = transform.InverseTransformPoint(hits[0].point);
        Vector3 relativePosition2 = transform.InverseTransformPoint(hits[hits.Length - 1].point);

        if (relativePosition1.x > 0 && relativePosition2.x > 0) // right
        {
            if (currentDirection == "NE") currentDirection = "NW";
            if (currentDirection == "SE") currentDirection = "SW";

            GetComponent<tk2dSprite>().FlipX = true;
        }
        if (relativePosition1.x < 0 && relativePosition2.x < 0) // left
        {
            if (currentDirection == "NW") currentDirection = "NE";
            if (currentDirection == "SW") currentDirection = "SE";

            GetComponent<tk2dSprite>().FlipX = false;
        }
        if (relativePosition1.y > 0 && relativePosition2.y > 0) // up
        {
            if (currentDirection == "NE") currentDirection = "SE";
            if (currentDirection == "NW") currentDirection = "SW";
        }
        if (relativePosition1.y < 0 && relativePosition2.y < 0) // down
        {
            if (currentDirection == "SE") currentDirection = "NE";
            if (currentDirection == "SW") currentDirection = "NW";
        }
    }

 void Explode(ContactPoint[] contacts)
 {
     gameObject.GetComponent<Rigidbody>().constraints = RigidbodyConstraints.FreezeAll;
     gameObject.GetComponent<Renderer>().enabled = false;
     if(halo != null)
     {
         halo.GetType().GetProperty("enabled").SetValue(halo, false, null);
     }
     Destroy(gameObject, ProjectileDeathTimer);//Kind of hacky, can modify to use the time property in the trail system.
 }

    public void ShowDustParticles(ContactPoint contactPoint)
    {
        if (contactPoint.point != null)
        {
            // Place Particle Effect where it hits the ground
            GameObject gObj = Instantiate(PFX_HittingGround);
            gObj.transform.position = contactPoint.point;

            // Play Hitting Sand Sound
            int soundNum = Random.Range (0,2);
            if(soundNum == 0) 		GetComponent<SoundsTriggered>().playSound2(true, 1);
            else if (soundNum == 1)	GetComponent<SoundsTriggered>().playSound3(true, 1);
        }
    }

 private void ProcessBuffPackage(ContactPoint contact, PackageType buffType)
 {
     TankHealth healthComponent = contact.otherCollider.GetComponent<TankHealth>();
     TankMovement movementComponent = contact.otherCollider.GetComponent<TankMovement>();
     switch (buffType)
     {
         case PackageType.Health:
             healthComponent.Heal(m_HealthBenefit);
             break;
         case PackageType.Speed:
             movementComponent.m_HasSpeedBuff = true;
             break;
         default:
             break;
     }
 }

   public void In(
      [FriendlyName("ContactPoint", "The ContactPoint to randomly choose from. Connect a ContactPoint List or individual ContactPoint variables to this socket.")]
      ContactPoint[] ObjectSet,

      [FriendlyName("Target ContactPoint", "The ContactPoint value that gets set.")]
      out ContactPoint Target
      )
   {
      if (ObjectSet == null)
      {
         Target = new ContactPoint();
         return;
      }

      int index = Random.Range(0, ObjectSet.Length);
      Target = ObjectSet[index];
   }

 public void In(
    [FriendlyName("Value", "The variable you wish to use to set the target's value.")]
    object Value,
    
    [FriendlyName("Target", "The Target variable you wish to set.")]
    out ContactPoint Target
    )
 {
    if ( Value.GetType() != typeof(ContactPoint) )
    {
       uScriptDebug.Log( "Set ContactPoint: Value is not a ContactPoint!", uScriptDebug.Type.Error );
       Target = new ContactPoint( );
    }
    else
    {
       Target = (ContactPoint) Value;
    }
 }

    public void LaunchBall(ContactPoint cp, bool platformFlag)
    {
        this.StopTheBall();
        this.BallRigRef.freezeRotation = false;
        Vector3 newDir = Vector3.zero;
        Vector3 curDir = this.BallRigRef.transform.TransformDirection(Vector3.forward);

        float differenceBetweenContactAndCenter = cp.point.x - this.gameObject.transform.position.x;

        if (platformFlag) //hit the platform
        {
            if (Mathf.Abs(differenceBetweenContactAndCenter) < 0.1f) // presuming it hit the center
            {
                newDir = Vector3.Reflect(curDir, cp.normal);
                LaunchBallStraight(newDir, curDir);
                this.BallRigRef.freezeRotation = true;
            }
            else // hit the side
            {
                float modifier = 60.0f * differenceBetweenContactAndCenter;
                GameObject.Find("RotationDummy").transform.Rotate(0.0f, modifier, 0.0f);
                Quaternion targetRotation = GameObject.Find("RotationDummy").transform.rotation;
                this.BallRigRef.transform.rotation = targetRotation;
                Vector3 targVector = this.BallRigRef.transform.TransformDirection(Vector3.forward);
                this.BallRigRef.AddForce(targVector * this.thrust);
                this.BallRigRef.freezeRotation = true;
                GameObject.Find("RotationDummy").transform.rotation = Quaternion.identity;
            }
        }
        else // hit something else
        {
            newDir = Vector3.Reflect(curDir, cp.normal);
            if (this.CheckForStraightAngleBug(newDir))
            {
                Vector3 tmpDir = new Vector3(newDir.x + (Random.Range(0.5f, 1.5f) - 1.0f), 0.0f, (Random.Range(0.5f, 1.5f) - 1.0f));
                newDir = tmpDir;
            }
            LaunchBallStraight(newDir, curDir);
            this.BallRigRef.freezeRotation = true;
        }

        this.lastCp = cp;
    }

    void Explode(ContactPoint[] contacts)
    {
        GameObject explosion = Instantiate(explosionPrefab, contacts[0].point, Quaternion.identity) as GameObject;
        Destroy(explosion, ExplosionDeathTimer);

        for (int i = -5; i <= 5; ++i)
        {
            for (int j = -5; j <= 5; ++j)
            {
                for (int k = -5; k <= 5; ++k)
                {
                    RaycastHit hit;
                    Ray ray = new Ray(transform.position, new Vector3(i, j, k));
                    Physics.Raycast(ray, out hit);
                    Rigidbody body = hit.rigidbody;
                    if (body != null)
                    {
                        Vector3 direction = body.transform.position - transform.position;
                        direction = direction.normalized;
                        body.AddForce(direction * ExplosionStrength);
                        Health hp = body.gameObject.GetComponent<Health>();
                        if(hp != null)
                        {
                            hp.TakeDamage(damage);
                        }
                        //if(body.gameObject.tag != "Player" && body.gameObject.tag != "Projectile")
                        //    Destroy(body.gameObject, 1.0f);
                    }
                }
            }
        }

        gameObject.GetComponent<Rigidbody>().constraints = RigidbodyConstraints.FreezeAll;
        gameObject.GetComponent<Rigidbody>().isKinematic = true;
        gameObject.GetComponent<Renderer>().enabled = false;
        Destroy(gameObject, ProjectileDeathTimer);
    }

 public void AddCollider(uint localID, ContactPoint contact)
 {
     if (!m_objCollisionList.ContainsKey(localID))
     {
         m_objCollisionList.Add(localID, contact);
     }
     else
     {              
         if (m_objCollisionList[localID].PenetrationDepth < contact.PenetrationDepth)
             m_objCollisionList[localID] = contact;
     }
 }

 public void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
 {
     CollisionEventsThisFrame.AddCollider(CollidedWith, contact);
 }

        internal void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
        {
            if (m_eventsubscription > 0)
            {
//                m_log.DebugFormat(
//                    "[PHYSICS]: Adding collision event for {0}, collidedWith {1}, contact {2}", "", CollidedWith, contact);

                CollisionEventsThisFrame.AddCollider(CollidedWith, contact);
            }
        }

 public void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
 {
     if (CollisionEventsThisFrame == null)
         CollisionEventsThisFrame = new CollisionEventUpdate();
     CollisionEventsThisFrame.addCollider(CollidedWith, contact);
 }

 public override void AddCollisionEvent (uint CollidedWith, ContactPoint contact)
 {
     if (base.SubscribedToCollisions () && SubscribedEvents())//If we don't have anything that we are going to trigger, don't even add
     {
         if (CollisionEventsThisFrame == null)
             CollisionEventsThisFrame = new CollisionEventUpdate ();
         CollisionEventsThisFrame.addCollider (CollidedWith, contact);
     }
 }

 /*
  * \brief Works out if a value is almost another value (for floating point accuracy)
 */
 public void CallOnCollisionContactEnter(ContactPoint contact)
 {
     // check the normal to see if the collision is in the horizontal plain
     if (!m_colliding && (contact.normal.y < 0.1 && contact.normal.y > -0.1))
     {
         m_velocity = 0.0f;
         m_colliding = true;
     }
 }

        private void collision_accounting_events(PhysicsActor p1, PhysicsActor p2, ContactPoint contact)
        {
            if (!p2.SubscribedEvents() && !p1.SubscribedEvents())
                return;
            FireCollisionEvent (p1, p2, contact);

            p1.AddCollisionEvent (p2.LocalID, contact);
            p2.AddCollisionEvent (p1.LocalID, contact);
        }

 public virtual void AddCollisionEvent(uint CollidedWith, ContactPoint contact) { }

 private void ProcessContact(uint cont, uint contWith, ContactPoint contact, 
             ref List<BulletDotNETPrim> primsWithCollisions,
             ref List<BulletDotNETCharacter> charactersWithCollisions)
 {
     BulletDotNETPrim bdnp;
     // collisions with a normal prim?
     if (m_primsLocalID.TryGetValue(cont, out bdnp))
     {
         // Added collision event to the prim. This creates a pile of events
         // that will be sent to any subscribed listeners.
         bdnp.AddCollision(contWith, contact);
         if (!primsWithCollisions.Contains(bdnp))
         {
             primsWithCollisions.Add(bdnp);
         }
     }
     else
     {
         BulletDotNETCharacter bdnc;
         // if not a prim, maybe it's one of the characters
         if (m_charactersLocalID.TryGetValue(cont, out bdnc))
         {
             bdnc.AddCollision(contWith, contact);
             if (!charactersWithCollisions.Contains(bdnc))
             {
                 charactersWithCollisions.Add(bdnc);
             }
         }
     }
 }

        private void collision_accounting_events(PhysicsActor p1, PhysicsActor p2, ContactPoint contact)
        {
            // obj1LocalID = 0;
            //returncollisions = false;
            obj2LocalID = 0;
            //ctype = 0;
            //cStartStop = 0;
            if (!p2.SubscribedEvents() && !p1.SubscribedEvents())
                return;

            switch ((ActorTypes)p2.PhysicsActorType)
            {
                case ActorTypes.Agent:
                    cc2 = (OdeCharacter)p2;

                    // obj1LocalID = cc2.m_localID;
                    switch ((ActorTypes)p1.PhysicsActorType)
                    {
                        case ActorTypes.Agent:
                            cc1 = (OdeCharacter)p1;
                            obj2LocalID = cc1.m_localID;
                            cc1.AddCollisionEvent(cc2.m_localID, contact);
                            //ctype = (int)CollisionCategories.Character;

                            //if (cc1.CollidingObj)
                            //cStartStop = (int)StatusIndicators.Generic;
                            //else
                            //cStartStop = (int)StatusIndicators.Start;

                            //returncollisions = true;
                            break;
                        case ActorTypes.Prim:
                            if (p1 is OdePrim)
                            {
                                cp1 = (OdePrim) p1;
                                obj2LocalID = cp1.m_localID;
                                cp1.AddCollisionEvent(cc2.m_localID, contact);
                            }
                            //ctype = (int)CollisionCategories.Geom;

                            //if (cp1.CollidingObj)
                            //cStartStop = (int)StatusIndicators.Generic;
                            //else
                            //cStartStop = (int)StatusIndicators.Start;

                            //returncollisions = true;
                            break;

                        case ActorTypes.Ground:
                        case ActorTypes.Unknown:
                            obj2LocalID = 0;
                            //ctype = (int)CollisionCategories.Land;
                            //returncollisions = true;
                            break;
                    }

                    cc2.AddCollisionEvent(obj2LocalID, contact);
                    break;
                case ActorTypes.Prim:

                    if (p2 is OdePrim)
                    {
                        cp2 = (OdePrim) p2;

                        // obj1LocalID = cp2.m_localID;
                        switch ((ActorTypes) p1.PhysicsActorType)
                        {
                            case ActorTypes.Agent:
                                if (p1 is OdeCharacter)
                                {
                                    cc1 = (OdeCharacter) p1;
                                    obj2LocalID = cc1.m_localID;
                                    cc1.AddCollisionEvent(cp2.m_localID, contact);
                                    //ctype = (int)CollisionCategories.Character;

                                    //if (cc1.CollidingObj)
                                    //cStartStop = (int)StatusIndicators.Generic;
                                    //else
                                    //cStartStop = (int)StatusIndicators.Start;
                                    //returncollisions = true;
                                }
                                break;
                            case ActorTypes.Prim:

                                if (p1 is OdePrim)
                                {
                                    cp1 = (OdePrim) p1;
                                    obj2LocalID = cp1.m_localID;
                                    cp1.AddCollisionEvent(cp2.m_localID, contact);
                                    //ctype = (int)CollisionCategories.Geom;

                                    //if (cp1.CollidingObj)
                                    //cStartStop = (int)StatusIndicators.Generic;
                                    //else
                                    //cStartStop = (int)StatusIndicators.Start;

                                    //returncollisions = true;
                                }
                                break;

//.........这里部分代码省略.........

//.........这里部分代码省略.........
                    (p1 as AuroraODEPrim)._zeroFlag = false;
            try
            {
                // Colliding Geom To Geom
                // This portion of the function 'was' blatantly ripped off from BoxStack.cs

                if (g1 == g2)
                    return; // Can't collide with yourself

                if (b1 != IntPtr.Zero && b2 != IntPtr.Zero && d.AreConnectedExcluding(b1, b2, d.JointType.Contact))
                    return;

                lock (contacts)
                {
                    count = d.Collide(g1, g2, (contacts.Length & 0xffff), contacts, d.ContactGeom.SizeOf);
                }
            }
            catch (SEHException)
            {
                m_log.Error("[PHYSICS]: The Operating system shut down ODE because of corrupt memory.  This could be a result of really irregular terrain.  If this repeats continuously, restart using Basic Physics and terrain fill your terrain.  Restarting the sim.");
                ode.drelease(world);
            }
            catch (Exception e)
            {
                m_log.WarnFormat("[PHYSICS]: Unable to collide test an object: {0}", e.ToString());
                return;
            }

            if (count == 0)
                return;

            m_StatFindContactsTime = Util.EnvironmentTickCountSubtract(FindContactsTime);

            ContactPoint maxDepthContact = new ContactPoint();
            if (!DisableCollisions)
            {
                if (p1.CollisionScore + count >= float.MaxValue)
                    p1.CollisionScore = 0;
                p1.CollisionScore += count;

                if (p2.CollisionScore + count >= float.MaxValue)
                    p2.CollisionScore = 0;
                p2.CollisionScore += count;
            }

            int ContactLoopTime = Util.EnvironmentTickCount();

            #region Contact Loop

            for (int i = 0; i < count; i++)
            {
                d.ContactGeom curContact = contacts[i];

                if (curContact.depth > maxDepthContact.PenetrationDepth)
                {
                    maxDepthContact.PenetrationDepth = curContact.depth;
                    maxDepthContact.Position.X = curContact.pos.X;
                    maxDepthContact.Position.Y = curContact.pos.Y;
                    maxDepthContact.Position.Z = curContact.pos.Z;
                    maxDepthContact.SurfaceNormal.X = curContact.normal.X;
                    maxDepthContact.SurfaceNormal.Y = curContact.normal.Y;
                    maxDepthContact.SurfaceNormal.Z = curContact.normal.Z;
                    //                    maxDepthContact = new ContactPoint(
                    //                        new Vector3((float)curContact.pos.X, (float)curContact.pos.Y, (float)curContact.pos.Z),
                    //                        new Vector3((float)curContact.normal.X, (float)curContact.normal.Y, (float)curContact.normal.Z),
                    //                        (float)curContact.depth