public bool BeginContact(Contact contact)
        {
            // If this is a collision between static objects, just disable it.
            if (contact.FixtureA.Body.BodyType == BodyType.Static && contact.FixtureB.Body.BodyType == BodyType.Static)
            {
                return false;
            }
            if (!contact.FixtureA.IsSensor && !contact.FixtureA.IsSensor)
            {
                Rigidbody rigidbodyA = contact.FixtureA.Body.UserData.rigidbody;
                Rigidbody rigidbodyB = contact.FixtureB.Body.UserData.rigidbody;

                // If we have real colliders clashing, one of them must have a rigid body
                // I don't dare disabling it though...
                if ((rigidbodyA == null) && (rigidbodyB == null))
                {
                    return true;
                }
                // If both are rigid bodies - none of them must be kinematic
                if ((rigidbodyA != null) && (rigidbodyB != null) && rigidbodyA.isKinematic && rigidbodyB.isKinematic)
                {
                    return true;
                }
            }
            beginContacts.Enqueue(new ColliderContact(contact));
            return true;
        }

        internal ContactManager()
        {
            ContactList = null;
            ContactCount = 0;

            OnBroadphaseCollision = AddPair;
        }

        private void PreSolve(Contact contact, ref Manifold oldManifold)
        {
            if ((Flags & DebugViewFlags.ContactPoints) == DebugViewFlags.ContactPoints)
            {
                Manifold manifold = contact.Manifold;

                if (manifold.PointCount == 0)
                    return;

                Fixture fixtureA = contact.FixtureA;

                FixedArray2<PointState> state1, state2;
                Collision.Collision.GetPointStates(out state1, out state2, ref oldManifold, ref manifold);

                FixedArray2<Vector2> points;
                Vector2 normal;
                contact.GetWorldManifold(out normal, out points);

                for (int i = 0; i < manifold.PointCount && _pointCount < MaxContactPoints; ++i)
                {
                    if (fixtureA == null)
                        _points[i] = new ContactPoint();

                    ContactPoint cp = _points[_pointCount];
                    cp.Position = points[i];
                    cp.Normal = normal;
                    cp.State = state2[i];
                    _points[_pointCount] = cp;
                    ++_pointCount;
                }
            }
        }

 private bool BeginFeetContact( Contact contact )
 {
     if ( contact.FixtureA == mFeet && !contact.FixtureB.IsSensor
          || contact.FixtureB == mFeet && !contact.FixtureA.IsSensor )
         ++mNumFootContacts;
     return true;
 }

 public void Add(Contact contact)
 {
     if (ContactCount >= ContactCapacity)
         return;
     //			Debug.Assert(ContactCount < ContactCapacity);
     _contacts[ContactCount++] = contact;
 }

        protected override bool OnCollision(Fixture projectile, Fixture collided, Contact contact)
        {
            if (NoCollide)
                return false;

            var collidedUnit = (collided.Body.UserData is Unit) ? (Unit)(collided.Body.UserData) : null;

            if (collidedUnit != null) {
                if (collidedUnit == Owner) {
                    Owner.ModifyAttackCooldown(-1000f);
                    Expire();
                }
                else {
                    foreach (Aura aura in Auras) {
                        collidedUnit.AddAura(aura);
                    }
                    collidedUnit.Hurt(Damage);
                    Body.LinearVelocity = Vector2.Zero;
                    Body.IgnoreGravity = false;
                    Body.ApplyLinearImpulse(new Vector2((Owner.Position.X - collidedUnit.Position.X)*7, -200));
                    Body.ApplyTorque(-2000f);
                    Body.CollidesWith = Category.Cat1 | Category.Cat2;
                    Body.CollisionCategories = Category.Cat5;
                }
            }

            return false;
        }

        // Collision handlers
        public bool CollisionWithEnemy(Fixture f1, Fixture f2, Contact contact)
        {
            Vector2 normal;
            FixedArray2<Vector2> points;
            contact.GetWorldManifold(out normal, out points);

            foreach (IGameComponent comp in this.game.Components)
            {
                GameEnemy enemy = comp as GameEnemy;
                if (enemy != null)
                {
                    if (enemy.getFixture() == f2)
                    {

                        if ((Math.Abs(normal.Y) > Math.Abs(normal.X)) && (normal.Y < 0))    // The contact is coming from above
                        {
                            enemy.Die(); // Uncomment this line if we decide to fix the timing so we dispose after the animation
                            this.increaseScore(10);
                            this.Jump();
                            break;
                        }
                        else
                        {
                            this.Die();
                        }

                        break;
                    }
                }
            }

            return true;
        }

        public virtual bool OnCollision(Fixture fixtureA, Fixture fixtureB, Contact contact)
        {
            Vector2 normal = Vector2.Zero;

            Contact currentContact = contact;
            Vector2 nextNormal = Vector2.Zero;
            FixedArray2<Vector2> fx; // No idea what that is, but the function wants it
            // Iterate through the contacts, summing the normals
            do
            {
                Vector2 vec = Vector2.Zero;
                contact.GetWorldManifold(out vec, out fx);
                normal += vec;
                currentContact = currentContact.Next;
            } while (currentContact != null);

            if (normal.Y > Y && normal.X == 0)
            {
                Pressed = true;

                _pressing.Add(fixtureB);
            }

            return true;
        }

        public bool onCollision(Fixture fixtureA, Fixture fixtureB, Contact contact)
        {
            Torque = -Torque;
            _fixtures.Last().Body.AngularVelocity = 0;

            return true;
        }

        public Boolean collisionBullet(Fixture fixA, Fixture fixB, Contact contact)
        {
            if (!isHung)
            //je joins la balle a la cible avec un angle strict, et la balle au joueur avec un distance joint
            {
                Vector2 diff = bullet.FixtureObject.Body.Position - fixB.Body.Position;
                //ObjCercle bulletTP = new ObjCercle(diff, radius, 0.0f, worldPhysic, fixB.Body);
                //worldPhysic.RemoveBody(bullet.FixtureObject.Body);
                //bullet = bulletTP;
                //bullet.addDisplayer();

                //juncture = new FarseerPhysics.Dynamics.Joints.DistanceJoint(juncturePoint.Body, bullet.FixtureObject.Body, new Vector2(1, 1)/*AnchorPointJuncturePoint*/, new Vector2(1, 1));
                //juncture = JointFactory.CreateDistanceJoint(worldPhysic, juncturePoint.Body, bullet.FixtureObject.Body, new Vector2(10,0)/*AnchorPointJuncturePoint*/, new Vector2(10,0));
                //worldPhysic.AddJoint(juncture);

                //junctureHook = JointFactory. CreateRevoluteJoint(worldPhysic, fixA.Body, fixB.Body, diff);
                //junctureHook.MaxImpulse = 3;
                //junctureHook.

                worldPhysic.RemoveBody(bullet.FixtureObject.Body);
                bullet = null;
                //bullet.FixtureObject.Body.BodyType = BodyType.Dynamic;
                juncture = new FarseerPhysics.Dynamics.Joints.DistanceJoint(juncturePoint.Body, fixB.Body, AnchorPointJuncturePoint, new Vector2(diff.X, diff.Y));

                worldPhysic.AddJoint(juncture);
                isHung = true;
            }
            return false;
        }

 public BodyCollisionEventArgs(BodyComponent bodyComponentA, BodyComponent bodyComponentB, Contact contact)
 {
     BodyComponentA = bodyComponentA;
     BodyComponentB = bodyComponentB;
     Contact = contact;
     IsColliding = true;
 }

 public void EndContact(Contact contact)
 {
     if (contact.FixtureA.Body.UserData != null && contact.FixtureB.Body.UserData != null)
     {
         endContacts.Enqueue(new ColliderContact(contact));
     }
 }

 public virtual bool OnCollidedWith(Fixture f, UserControlledCharacter obj, Fixture f2, Contact info)
 {
     if (Engine.CameraLock)
     {
         Engine.CameraLock = false;
     }
     return false;
 }

 private bool OnCollision( Fixture fixtureA, Fixture fixtureB, Contact contact )
 {
     if ( !fixtureB.IsSensor && fixtureB.UserData is Flat )
     {
         var diff = MathHelper.WrapAngle( UpDir.Angle - Rotation );
         Rotation = Rotation + diff;
     }
     return contact.IsTouching;
 }

 public bool onCollision(Fixture fixtureA, Fixture fixtureB, Contact contact)
 {
     //if (_fixtures.Count > 0 && _fixtures[0].Body.BodyType == BodyType.Static && fixtureB.UserData is Player)
     //{
     //    _fixtures[0].Body.BodyType = BodyType.Dynamic;
     //    _fixtures[0].Body.SleepingAllowed = false;
     //}
     return true;
 }

        bool OnCollision(Fixture fixtureA, Fixture fixtureB, Contact contact)
        {
            if (fixtureB.UserData is EnemyBarrier) {
                direction.X = -direction.X;
                return false;
            }

            return true;
        }

        protected override bool OnCollision(Fixture fix1, Fixture fix2, Contact contact) {
            base.OnCollision(fix1, fix2, contact);

            if (contact.IsTouching && contact.Manifold.LocalNormal.Y < 0) {
                canJump = true;
                isJumping = false;
            }
            return true;
        }

 private bool OnCollision(Fixture fixtureA, Fixture fixtureB, Contact contact)
 {
     if (fixtureB.CollisionCategories == Category.Cat3)
     {
         fixtureB.Body.Dispose();
         System.Diagnostics.Debug.WriteLine("body removed");
     }
     return true;
 }

 bool HandleCollision(Fixture fixtureA, Fixture fixtureB, Contact contact)
 {
     WeakReference scene_wr = new WeakReference(Set.Scene);
     _RenderSet.Scene.Game.AddUpdateEventHandler(this, (sender, e) => {
         new BulletCollisionParticle((Scene)scene_wr.Target, PositionX, PositionY).CenterShift();
         Derez();
         return true;
     });
     return true;
 }

 bool OnCollision(Fixture fixtureA, Fixture fixtureB, Contact contact)
 {
     var crateBody = fixtureB.Body;
     var crate = crateBody.UserData as Crate;
     if (crate != null)
     {
         GameWorld.RemoveCrate(crate);
     }
     return true;
 }