// Collision order: projectile to player, projectile to enemy, projectile to item
        public List <Collision> GetCollisionList()
        {
            // Projectile hits Player
            foreach (IProjectile proj in projectileList)
            {
                Rectangle projHitbox = proj.GetHitbox();

                // Projectile hits Player
                foreach (IPlayer player in players)
                {
                    DetectionUtil.AddCollision(projHitbox, player.GetPlayerHitbox(), proj, player, collisionList);
                }

                // Projectile hits Enemy
                foreach (IEnemy enemy in enemyList)
                {
                    foreach (Rectangle enemyHitbox in enemy.GetHitboxes())
                    {
                        DetectionUtil.AddCollision(projHitbox, enemyHitbox, proj, enemy, collisionList);
                    }
                }

                // Projectile hits Item
                foreach (IItem item in itemList)
                {
                    DetectionUtil.AddCollision(projHitbox, item.GetHitbox(), proj, item, collisionList);
                }
            }

            return(collisionList);
        }
Exemple #2
0
        public List <Collision> GetCollisionList()
        {
            // Enemy collides with Player
            foreach (IEnemy enemy in enemyList)
            {
                foreach (Rectangle enemyHitbox in enemy.GetHitboxes())
                {
                    foreach (IPlayer player in players)
                    {
                        DetectionUtil.AddCollision(enemyHitbox, player.GetPlayerHitbox(), enemy, player, collisionList);
                    }
                }
            }

            // Enemy collides with Environment
            foreach (IEnemy enemy in enemyList)
            {
                foreach (Rectangle enemyHitbox in enemy.GetHitboxes())
                {
                    foreach (IEnvironment environment in environmentList)
                    {
                        foreach (Rectangle envHitbox in environment.GetHitboxes())
                        {
                            if (DetectionUtil.AddCollision(enemyHitbox, envHitbox, enemy, environment, collisionList))
                            {
                                goto NextEnemy;
                            }
                        }
                    }
                }
NextEnemy:
                continue;
            }

            return(collisionList);
        }
Exemple #3
0
        // Collision order: player to item, player to enemy
        public List <Collision> GetCollisionList()
        {
            foreach (IPlayer player in players)
            {
                playerHitbox = player.GetPlayerHitbox();
                swordHitbox  = player.GetSwordHitbox();

                // Player/Sword collides with Item
                foreach (IItem item in ItemList)
                {
                    if (!DetectionUtil.AddCollision(playerHitbox, item.GetHitbox(), player, item, collisionList) && !InvalidSwordPickups.Contains(item.GetType()))
                    {
                        DetectionUtil.AddCollision(swordHitbox, item.GetHitbox(), player, item, collisionList);
                    }
                }

                // Sword collides with Enemy
                foreach (IEnemy enemy in EnemyList)
                {
                    foreach (Rectangle enemyHitbox in enemy.GetHitboxes())
                    {
                        DetectionUtil.AddCollision(swordHitbox, enemyHitbox, player, enemy, collisionList);
                    }
                }

                bool collision = false;
                foreach (IEnvironment environment in CollisionDetectionUtil.DetectionUtil.GetSingleCollisionObjects(EnvironmentList))
                {
                    foreach (Rectangle envHitbox in environment.GetHitboxes())
                    {
                        // Player collides with Environment
                        Rectangle intersectPlayer = Rectangle.Intersect(playerHitbox, envHitbox);
                        if (!intersectPlayer.IsEmpty)
                        {
                            var side = CollisionDetectionUtil.DetectionUtil.DetermineSide(playerHitbox, envHitbox, intersectPlayer);
                            collisionList.Add(new Collision(side, intersectPlayer, player, environment));

                            if (environment is LoadZone)
                            {
                                foundLoadZoneCollision[outerLoadZoneLoopCounter] = true;
                            }

                            collision = true;
                            break;
                        }
                    }
                    if (collision)
                    {
                        break;
                    }
                }

                // Player collides with multi-collision environment
                foreach (IEnvironment environment in CollisionDetectionUtil.DetectionUtil.GetMultiCollisionObjects(EnvironmentList))
                {
                    foreach (Rectangle envHitbox in environment.GetHitboxes())
                    {
                        DetectionUtil.AddCollision(playerHitbox, envHitbox, player, environment, collisionList);
                    }
                }

                // Player collides with Player
                innerLoadZoneLoopCounter = 0;
                foreach (IPlayer player2 in players)
                {
                    Rectangle player2Hitbox = player2.GetPlayerHitbox();

                    Rectangle intersectPlayer = Rectangle.Intersect(playerHitbox, player2Hitbox);
                    if ((intersectPlayer.Width == playerHitbox.Width && intersectPlayer.Height == playerHitbox.Height) || player.requesting || player2.requesting)
                    {
                        // Do nothing if they are the same or if player is requesting
                    }
                    else if (!intersectPlayer.IsEmpty)
                    {
                        var side = CollisionDetectionUtil.DetectionUtil.DetermineSide(playerHitbox, player2Hitbox, intersectPlayer);
                        collisionList.Add(new Collision(side, intersectPlayer, player, player2));
                        collision = true;
                        break;
                    }

                    innerLoadZoneLoopCounter++;

                    if (collision)
                    {
                        break;
                    }
                }

                //player intersecting with outside bounds
                foreach (Rectangle bound in roomBounds)
                {
                    Rectangle intersectPlayer = Rectangle.Intersect(playerHitbox, bound);
                    if (!intersectPlayer.IsEmpty)
                    {
                        var side = CollisionDetectionUtil.DetectionUtil.DetermineSide(playerHitbox, bound, intersectPlayer);
                        collisionList.Add(new Collision(side, intersectPlayer, player, EnvironmentList[0])); //environment object here is passed as a "dummy". There will always be at least 1 evnironment object
                        foundLoadZoneCollision[outerLoadZoneLoopCounter] = true;
                    }
                }
                player.requesting = foundLoadZoneCollision[outerLoadZoneLoopCounter];

                Rectangle innerRoomInt = Rectangle.Intersect(playerHitbox, roomInner);
                if (!innerRoomInt.IsEmpty)
                {
                    RoomUtil.ExitDoor(player.playerID);
                }
                else
                {
                    foundLoadZoneCollision[outerLoadZoneLoopCounter] = true;
                    player.requesting = true;
                }

                outerLoadZoneLoopCounter++;
            }
            return(collisionList);
        }