Example #1
0
 internal void Collision(Collider2D other, CollisionPairState state, HitState hitState)
 {
     if (state.enter)
     {
         CollisionEnter?.Invoke(other, hitState);
     }
     if (state.stay)
     {
         CollisionStay?.Invoke(other, hitState);
     }
     if (state.exit)
     {
         CollisionExit?.Invoke(other, hitState);
     }
 }
        public static HitState OnAABB(BoxCollider a, BoxCollider b)
        {
            HitState hitState = new HitState();

            //Faccio delle valutazioni sull'asse x
            float dx = b.Center.X - a.Center.X;
            //Calcolo della distanza tra le pareti lungo l'asse x
            float px = (b.Half.X + a.Half.X) - Math.Abs(dx);    //differenza tra la somma dei raggi e il valore assoluto di dx

            //Valuto se è avvenuta la collisione tra pareti lungo asse x
            if (px <= 0f)
            {
                //non ho colliso
                return(hitState);
            }

            //Faccio delle valutazioni sull'asse y
            float dy = b.Center.Y - a.Center.Y;
            //Calcolo della distanza tra le pareti lungo l'asse y
            float py = (b.Half.Y + a.Half.Y) - Math.Abs(dy);

            //Valuto se è avvenuta la collisione tra pareti lungo asse y
            if (py <= 0f)
            {
                //non ho colliso
                return(hitState);
            }

            // se sono verificate entrambe le condizioni di cui sopra, allora siamo certi che è avvenuta una collisione, perciò...
            hitState.hit = true;

            if (px < py)
            {
                //la normale è posta lungo l'asse x
                int sx = Math.Sign(dx);
                hitState.normal = new Vector2(-sx, 0f);
            }
            else
            {
                //la normale è posta lungo l'asse y
                int sy = Math.Sign(dy);
                hitState.normal = new Vector2(0f, -sy);
            }

            return(hitState);
        }
Example #3
0
        private HitState AABBvsAABB(BoxCollider2D a, BoxCollider2D b)
        {
            HitState hitState = new HitState();

            //evaluate x axis
            float dx = b.Center.X - a.Center.X;
            //calculate distance along x axis
            float px = (b.HalfSize.X + a.HalfSize.X) - Math.Abs(dx);    //difference between the sum of radius and the absolute value of dx

            //check collision on x axis
            if (px <= 0f)
            {
                //no collision
                return(hitState);
            }

            //evaluate y axis
            float dy = b.Center.Y - a.Center.Y;
            //calculate distance along y axis
            float py = (b.HalfSize.Y + a.HalfSize.Y) - Math.Abs(dy);    //difference between the sum of radius and the absolute value of dy

            //check collision on y axis
            if (py <= 0f)
            {
                //no collision
                return(hitState);
            }

            // if code reaches this point, the boxes enter on collision
            hitState.hit = true;

            if (px < py)
            {
                //normal is on x axis
                int sx = Math.Sign(dx);
                hitState.normal = new Vector2(-sx, 0f);
            }
            else
            {
                //normal is on x axis
                int sy = Math.Sign(dy);
                hitState.normal = new Vector2(0f, -sy);
            }

            return(hitState);
        }
Example #4
0
        private void CheckAndResolveCollisions()
        {
            for (int i = 0; i < collisionPairs.Count; i++)
            {
                if (collisionPairs[i].IsPairEnabled)
                {
                    switch (collisionPairs[i].PairCollisionMode)
                    {
                    case CollisionMode.Trigger:
                        if (collisionPairs[i].collider1 is BoxCollider2D && collisionPairs[i].collider2 is BoxCollider2D)
                        {
                            if (this.Intersect(collisionPairs[i].collider1 as BoxCollider2D, collisionPairs[i].collider2 as BoxCollider2D))
                            {
                                collisionPairs[i].Trigger(true);
                            }
                            else
                            {
                                collisionPairs[i].Trigger(false);
                            }
                        }

                        else if (collisionPairs[i].collider1 is CircleCollider2D && collisionPairs[i].collider2 is CircleCollider2D)
                        {
                            if (this.Intersect(collisionPairs[i].collider1 as CircleCollider2D, collisionPairs[i].collider2 as CircleCollider2D))
                            {
                                collisionPairs[i].Trigger(true);
                            }
                            else
                            {
                                collisionPairs[i].Trigger(false);
                            }
                        }

                        else if (collisionPairs[i].collider1 is CircleCollider2D && collisionPairs[i].collider2 is BoxCollider2D)
                        {
                            if (this.Intersect(collisionPairs[i].collider1 as CircleCollider2D, collisionPairs[i].collider2 as BoxCollider2D))
                            {
                                collisionPairs[i].Trigger(true);
                            }
                            else
                            {
                                collisionPairs[i].Trigger(false);
                            }
                        }

                        else if (collisionPairs[i].collider1 is BoxCollider2D && collisionPairs[i].collider2 is CircleCollider2D)
                        {
                            if (this.Intersect(collisionPairs[i].collider2 as CircleCollider2D, collisionPairs[i].collider1 as BoxCollider2D))
                            {
                                collisionPairs[i].Trigger(true);
                            }
                            else
                            {
                                collisionPairs[i].Trigger(false);
                            }
                        }

                        break;

                    case CollisionMode.Collision:
                        if (LayerManager.CanCollide(collisionPairs[i]))
                        {
                            if (collisionPairs[i].collider1 is BoxCollider2D && collisionPairs[i].collider2 is BoxCollider2D)
                            {
                                BoxCollider2D boxA = collisionPairs[i].collider1 as BoxCollider2D;
                                BoxCollider2D boxB = collisionPairs[i].collider2 as BoxCollider2D;

                                HitState hitState = AABBvsAABB(boxA, boxB);

                                collisionPairs[i].Collision(hitState);

                                if (collisionPairs[i].collisionPairState.stay)
                                {
                                    ResolveCollision(boxA, boxB, hitState.normal);
                                }
                            }
                        }

                        break;
                    }
                }
            }
        }
 internal void Collision(HitState hitState)
 {
     collisionPairState.Update(hitState.hit);
     collider1.Collision(collider2, collisionPairState, hitState);
     collider2.Collision(collider1, collisionPairState, hitState);
 }