Esempio n. 1
0
        public static void IceballCollideWithBlock(IceballObject iceball, IGameObject block)
        {
            Level      level            = Game1.Instance.currentState.Level;
            Rectangle  iceballRectangle = iceball.GetHitBox();
            Rectangle  blockRectangle   = block.GetHitBox();
            IBlock     castBlock        = (IBlock)block;
            ICollision collisionSide    = CollisionSideDetector.DetectCollisionSide(iceballRectangle, blockRectangle);

            if (castBlock.State is HiddenItemBlockState)
            {
                return;
            }

            if (collisionSide is TopCollision)
            {
                iceball.Position = new Vector2(iceball.Position.X, iceball.Position.Y - collisionSide.CollisionIntersection.Height);
                iceball.BounceOffGround();
            }
            else if (collisionSide is RightCollision)
            {
                level.AddObject(new IceballExplosion((int)iceball.Position.X, (int)iceball.Position.Y));
                iceball.Explode();
            }
            else if (collisionSide is LeftCollision)
            {
                level.AddObject(new IceballExplosion((int)iceball.Position.X, (int)iceball.Position.Y));
                iceball.Explode();
            }
            else if (collisionSide is BottomCollision)
            {
                level.AddObject(new IceballExplosion((int)iceball.Position.X, (int)iceball.Position.Y));
                iceball.PhysicsObject.dy = 10.0F;
            }
        }
        public static void MarioCollideWithEnemy(IMario mario, IGameObject enemy)
        {
            Rectangle  marioRectangle = mario.RetrieveMarioRectangle();
            Rectangle  enemyRectangle = enemy.GetHitBox();
            ICollision collisionSide  = CollisionSideDetector.DetectCollisionSide(marioRectangle, enemyRectangle);
            IEnemy     collidedEnemy  = (IEnemy)enemy;

            if (collisionSide is RightCollision)
            {
                mario.Position = new Vector2(mario.Position.X - collisionSide.CollisionIntersection.Width, mario.Position.Y);
                if (!(mario is StarMario) && !(collidedEnemy.State is StompedKoopaState))
                {
                    new ShrunkenMario(mario, Game1.Instance);
                }
                if (!(collidedEnemy.State is StompedKoopaState))
                {
                    mario.GetHit();
                }
                collidedEnemy.HitFromLeft((IGameObject)mario);
            }
            else if (collisionSide is LeftCollision)
            {
                mario.Position = new Vector2(mario.Position.X + collisionSide.CollisionIntersection.Width, mario.Position.Y);
                if (!(mario is StarMario) && !(collidedEnemy.State is StompedKoopaState))
                {
                    new ShrunkenMario(mario, Game1.Instance);
                }
                if (!(collidedEnemy.State is StompedKoopaState))
                {
                    mario.GetHit();
                }
                collidedEnemy.HitFromRight((IGameObject)mario);
            }
            else if (collisionSide is TopCollision)
            {
                mario.Position = new Vector2(mario.Position.X, mario.Position.Y - collisionSide.CollisionIntersection.Height - 5);
                mario.physicsObject.aerialSpeed = 10;
                mario.physicsObject.dy          = 0;
                mario.physicsObject.Jump();
                IEnemy hitEnemy = (IEnemy)enemy;
                hitEnemy.BeStomped();
            }
            else if (collisionSide is BottomCollision)
            {
                mario.Position = new Vector2(mario.Position.X, mario.Position.Y + collisionSide.CollisionIntersection.Height);
                if (!(collidedEnemy.State is StompedKoopaState))
                {
                    mario.GetHit();
                }
            }
        }
        public static void ItemCollideWithEnvironment(IItem item, IGameObject environment)
        {
            Rectangle  itemRectangle        = item.GetHitBox();
            Rectangle  environmentRectangle = environment.GetHitBox();
            ICollision collisionSide        = CollisionSideDetector.DetectCollisionSide(itemRectangle, environmentRectangle);

            if (collisionSide is RightCollision)
            {
                item.SideCollisionResponse();
                item.Position = new Vector2(item.Position.X - collisionSide.CollisionIntersection.Width, item.Position.Y);
            }
            else if (collisionSide is LeftCollision)
            {
                item.SideCollisionResponse();
                item.Position = new Vector2(item.Position.X + collisionSide.CollisionIntersection.Width, item.Position.Y);
            }
            else if (collisionSide is TopCollision)
            {
                if (environment is IBlock block)
                {
                    if (block.WasHit)
                    {
                        item.SideCollisionResponse();
                    }
                    if (!(block.State is HiddenItemBlockState))
                    {
                        item.Position  = new Vector2(item.Position.X, item.Position.Y - collisionSide.CollisionIntersection.Height);
                        item.IsFalling = false;
                    }
                    else
                    {
                        item.IsFalling = true;
                    }
                }
                else
                {
                    item.Position  = new Vector2(item.Position.X, item.Position.Y - collisionSide.CollisionIntersection.Height);
                    item.IsFalling = false;
                }
            }
        }
Esempio n. 4
0
        public static void MarioCollideWithBlock(IMario mario, IGameObject block)
        {
            Rectangle  marioRectangle = mario.RetrieveMarioRectangle();
            Rectangle  blockRectangle = block.GetHitBox();
            ICollision collisionSide  = CollisionSideDetector.DetectCollisionSide(marioRectangle, blockRectangle);
            IBlock     collidedBlock  = (IBlock)block;

            if (collisionSide is RightCollision && !(collidedBlock.State is HiddenItemBlockState))
            {
                mario.Position = new Vector2(mario.Position.X - collisionSide.CollisionIntersection.Width, mario.Position.Y);
            }
            else if (collisionSide is LeftCollision && !(collidedBlock.State is HiddenItemBlockState))
            {
                mario.Position = new Vector2(mario.Position.X + collisionSide.CollisionIntersection.Width, mario.Position.Y);
            }
            else if (collisionSide is TopCollision && !(collidedBlock.State is HiddenItemBlockState))
            {
                mario.Position = new Vector2(mario.Position.X, mario.Position.Y - collisionSide.CollisionIntersection.Height);
            }
            else if (collisionSide is BottomCollision)
            {
                mario.Position = new Vector2(mario.Position.X, mario.Position.Y + collisionSide.CollisionIntersection.Height);
                if ((block is IBlock hitBlock) && !mario.isFalling)
                {
                    if (mario.BigMario)
                    {
                        hitBlock.BeHit();
                    }
                    else
                    {
                        hitBlock.BeBumped();
                    }
                    mario.isJumping = false;
                    mario.isFalling = true;
                    mario.physicsObject.aerialSpeed = 0;
                }
            }
        }
        public static void MarioCollideWithPipe(IMario mario, IPipe pipe)
        {
            Rectangle  marioRectangle = mario.RetrieveMarioRectangle();
            Rectangle  pipeRectangle  = pipe.GetHitBox();
            ICollision collisionSide  = CollisionSideDetector.DetectCollisionSide(marioRectangle, pipeRectangle);

            if (collisionSide is RightCollision)
            {
                mario.Position = new Vector2(mario.Position.X - collisionSide.CollisionIntersection.Width, mario.Position.Y);
                if (pipe is SidewaysPipe)
                {
                    SidewaysPipe enteredPipe = (SidewaysPipe)pipe;
                    enteredPipe.EnterPipe();
                }
            }
            else if (collisionSide is LeftCollision)
            {
                mario.Position = new Vector2(mario.Position.X + collisionSide.CollisionIntersection.Width, mario.Position.Y);
            }
            else if (collisionSide is TopCollision)
            {
                mario.Position = new Vector2(mario.Position.X, mario.Position.Y - collisionSide.CollisionIntersection.Height);
                if (mario.isFalling)
                {
                    mario.Idle();
                }
                if (pipe is PipeLargeEnterable)
                {
                    mario.onPipe = true;
                }
            }
            else if (collisionSide is BottomCollision)
            {
                mario.Position = new Vector2(mario.Position.X, mario.Position.Y + collisionSide.CollisionIntersection.Height);
            }
        }
Esempio n. 6
0
        public void DetectCollision(IMario mario)
        {
            gameObjects = new List <IGameObject>(currentLevel.GetObjects());
            gameObjects.AddRange(currentLevel.BigFloorRectangles);
            onScreenObjects = new List <IGameObject>(currentLevel.GetOnScreenObjects());
            onScreenObjects.AddRange(currentLevel.BigFloorRectangles);
            gameEnemies   = new List <IEnemy>(currentLevel.GetEnemies());
            gameItems     = new List <IItem>(currentLevel.GetItems());
            gameFireballs = new List <FireballObject>(currentLevel.GetFireballs());
            gameIceballs  = new List <IceballObject>(currentLevel.GetIceballs());
            Rectangle          marioRectangle         = mario.RetrieveMarioRectangle();
            Rectangle          extendedMarioRectangle = new Rectangle(marioRectangle.X, marioRectangle.Y, marioRectangle.Width, marioRectangle.Height + 2);
            List <IGameObject> marioFloorCollisions   = new List <IGameObject>();
            List <IGameObject> multipleCollision      = new List <IGameObject>();

            //checking for mario collisions
            foreach (IGameObject collidedObject in onScreenObjects)
            {
                Rectangle collidedObjectRectangle = collidedObject.GetHitBox();
                if (marioRectangle.Intersects(collidedObjectRectangle))
                {
                    if (collidedObject is IBlock)
                    {
                        mario.onPipe = false;
                        multipleCollision.Add(collidedObject);
                    }
                    else if (collidedObject is IPipe)
                    {
                        MasterCollisionResponder.PipeCollision(mario, collidedObject);
                    }
                    else if (collidedObject is FlagPole flag)
                    {
                        flag.SideCollisionResponse();
                        flag.GivePoints((int)mario.Position.Y + 32);
                    }
                }

                //temp is a cast of the collidedOBject to IBlock so that we can access the state of the block. We do this so that Mario does not see HiddenBlocks as floor blocks
                IBlock temp = null;
                if (collidedObject is IBlock)
                {
                    temp = (IBlock)collidedObject;
                }
                if (extendedMarioRectangle.Intersects(collidedObjectRectangle) &&
                    CollisionSideDetector.DetectCollisionSide(extendedMarioRectangle, collidedObjectRectangle) is TopCollision &&
                    ((collidedObject is IBlock && !(temp.State is HiddenItemBlockState)) || collidedObject is IPipe))
                {
                    marioFloorCollisions.Add(collidedObject);
                }
            }

            //collide with only one block at a time
            IGameObject maxIntersect;

            if (multipleCollision.Count > 0)
            {
                maxIntersect = multipleCollision[0];
                foreach (IGameObject gameObject in multipleCollision)
                {
                    Rectangle collidedObjectRectangle = gameObject.GetHitBox();
                    if (marioRectangle.Intersects(collidedObjectRectangle))
                    {
                        Rectangle newIntersect    = Rectangle.Intersect(marioRectangle, collidedObjectRectangle);
                        Rectangle oldMaxIntersect = Rectangle.Intersect(marioRectangle, maxIntersect.GetHitBox());
                        if (newIntersect.Width * newIntersect.Height > oldMaxIntersect.Width * oldMaxIntersect.Height)
                        {
                            maxIntersect = gameObject;
                        }
                    }
                }
                MasterCollisionResponder.BlockCollision(mario, maxIntersect);
            }
            //mario collide with items
            foreach (IItem item in gameItems)
            {
                Rectangle collidedObjectRectangle = item.GetHitBox();
                if (marioRectangle.Intersects(collidedObjectRectangle))
                {
                    MasterCollisionResponder.ItemCollision(mario, item);
                }
            }
            //mario collide with enemies
            foreach (IEnemy enemy in gameEnemies)
            {
                Rectangle collidedEnemyRectangle = enemy.GetHitBox();
                if (marioRectangle.Intersects(collidedEnemyRectangle))
                {
                    MasterCollisionResponder.EnemyCollision(mario, enemy);
                }
            }

            if (marioFloorCollisions.Count == 0 && !mario.isJumping)
            {
                mario.Fall();
            }
            if (marioFloorCollisions.Count > 0 && mario.isFalling)
            {
                mario.Land();
            }

            //checking for enemy collisions
            foreach (IEnemy enemy in gameEnemies)
            {
                Rectangle          enemyRectangle       = enemy.GetHitBox();
                List <IGameObject> enemyFloorCollisions = new List <IGameObject>();
                foreach (IGameObject collidedObject in gameObjects)
                {
                    if (!enemy.Equals(collidedObject))
                    {
                        Rectangle collidedObjectRectangle = collidedObject.GetHitBox();
                        if (enemyRectangle.Intersects(collidedObjectRectangle))
                        {
                            if (collidedObject is IPipe || ((collidedObject is IBlock block) && !(block.State is HiddenItemBlockState)))
                            {
                                MasterCollisionResponder.EnemyEnvironmentCollision(enemy, collidedObject);
                            }
                        }
                        Rectangle extendedEnemyRectangle = new Rectangle(enemyRectangle.X, enemyRectangle.Y, enemyRectangle.Width, enemyRectangle.Height + 2);
                        if (extendedEnemyRectangle.Intersects(collidedObjectRectangle) && (collidedObject is IBlock || collidedObject is IPipe))
                        {
                            if ((collidedObject is IBlock block) && !(block.State is HiddenItemBlockState))
                            {
                                enemyFloorCollisions.Add(collidedObject);
                            }
                        }
                    }
                }
                foreach (IEnemy collidedObject in gameEnemies)
                {
                    if (!enemy.Equals(collidedObject) && enemyRectangle.Intersects(collidedObject.GetHitBox()))
                    {
                        MasterCollisionResponder.EnemyEnvironmentCollision(enemy, collidedObject);
                    }
                }

                //if the enemy's extended box did not have any floor collisions, the enemy should be falling
                if (enemyFloorCollisions.Count == 0)
                {
                    enemy.IsFalling = true;
                }
            }

            //checking for item collisions
            foreach (IItem item in gameItems)
            {
                IGameObject obj           = item;
                Rectangle   itemRectangle = obj.GetHitBox();
                {
                    List <IGameObject> itemFloorCollisions = new List <IGameObject>();
                    foreach (IGameObject collidedObject in gameObjects)
                    {
                        if (!item.Equals(collidedObject))
                        {
                            Rectangle collidedObjectRectangle = collidedObject.GetHitBox();
                            if (itemRectangle.Intersects(collidedObjectRectangle))
                            {
                                if (collidedObject is IPipe || ((collidedObject is IBlock block) && !(block.State is HiddenItemBlockState)))
                                {
                                    MasterCollisionResponder.ItemEnvironmentCollision(item, collidedObject);
                                }
                            }

                            Rectangle extendedItemRectangle = new Rectangle(itemRectangle.X, itemRectangle.Y, itemRectangle.Width, itemRectangle.Height + 2);
                            if (extendedItemRectangle.Intersects(collidedObjectRectangle))
                            {
                                if ((collidedObject is IBlock block) && !(block.State is HiddenItemBlockState))
                                {
                                    itemFloorCollisions.Add(collidedObject);
                                }
                            }
                        }
                    }

                    //if the item's extended box did not have any floor collisions, the item should be falling
                    if (itemFloorCollisions.Count == 0)
                    {
                        item.IsFalling = true;
                    }
                }
            }

            //checking for fireball and iceball collisions
            foreach (FireballObject fireball in gameFireballs)
            {
                MasterCollisionResponder.FireballCollision(fireball);
            }
            foreach (IceballObject fireball in gameIceballs)
            {
                MasterCollisionResponder.IceballCollision(fireball);
            }
        }
        public static void EnemyCollideWithEnvironment(IEnemy enemy, IGameObject environment)
        {
            Rectangle  enemyRectangle       = enemy.GetHitBox();
            Rectangle  environmentRectangle = environment.GetHitBox();
            ICollision collisionSide        = CollisionSideDetector.DetectCollisionSide(enemyRectangle, environmentRectangle);

            if (collisionSide is RightCollision)
            {
                //let koopa shells kill
                if (environment is Koopa koopa)
                {
                    if (koopa.State is LeftSlidingShellState || koopa.State is RightSlidingShellState)
                    {
                        enemy.BeFlipped();
                        SoundFactory.Instance.Play(SoundFactory.Effects.Kick);
                    }
                    else if (!(enemy is LeftSlidingShellState || enemy is RightSlidingShellState))
                    {
                        environment.SideCollisionResponse();
                    }
                }
                else if (environment is IEnemy collidedEnemy)
                {
                    if (enemy.State is LeftSlidingShellState || enemy.State is RightSlidingShellState)
                    {
                        collidedEnemy.BeFlipped();
                        SoundFactory.Instance.Play(SoundFactory.Effects.Kick);
                    }
                    else if (!(enemy is LeftSlidingShellState || enemy is RightSlidingShellState))
                    {
                        environment.SideCollisionResponse();
                    }
                }
                else
                {
                    enemy.SideCollisionResponse();
                }

                enemy.Position = new Vector2(enemy.Position.X - collisionSide.CollisionIntersection.Width, enemy.Position.Y);
            }
            else if (collisionSide is LeftCollision)
            {
                //let koopa shells kill
                if (environment is Koopa koopa)
                {
                    if (koopa.State is LeftSlidingShellState || koopa.State is RightSlidingShellState)
                    {
                        enemy.BeFlipped();
                        SoundFactory.Instance.Play(SoundFactory.Effects.Kick);
                    }
                    else if (!(enemy is LeftSlidingShellState || enemy is RightSlidingShellState))
                    {
                        environment.SideCollisionResponse();
                    }
                }
                else if (environment is IEnemy collidedEnemy)
                {
                    if (enemy.State is LeftSlidingShellState || enemy.State is RightSlidingShellState)
                    {
                        collidedEnemy.BeFlipped();
                    }
                    else if (!(enemy is LeftSlidingShellState || enemy is RightSlidingShellState))
                    {
                        environment.SideCollisionResponse();
                    }
                }
                else
                {
                    enemy.SideCollisionResponse();
                }
                enemy.Position = new Vector2(enemy.Position.X + collisionSide.CollisionIntersection.Width, enemy.Position.Y);
            }
            else if (collisionSide is TopCollision && (environment is IBlock || environment is IPipe))
            {
                if (environment is IBlock block)
                {
                    if (block.WasHit)
                    {
                        enemy.BeFlipped();
                        SoundFactory.Instance.Play(SoundFactory.Effects.Kick);
                    }
                    if (!(block.State is HiddenItemBlockState))
                    {
                        enemy.Position  = new Vector2(enemy.Position.X, enemy.Position.Y - collisionSide.CollisionIntersection.Height);
                        enemy.IsFalling = false;
                    }
                }
                else
                {
                    enemy.Position  = new Vector2(enemy.Position.X, enemy.Position.Y - collisionSide.CollisionIntersection.Height);
                    enemy.IsFalling = false;
                }
            }
            else if (collisionSide is TopCollision && environment is IEnemy)
            {
                IEnemy collidedEnemy = (IEnemy)environment;
                collidedEnemy.BeFlipped();
            }
        }