示例#1
0
        /// <summary>
        /// Constructor call.  Creates a new Door object.
        /// </summary>
        /// <param name="content">The content manager to use when loading assets.</param>
        /// <param name="orient">The orientation of the room (either facing left or facing right).</param>
        /// <param name="roomName">The name of the room that the door leads to.</param>
        /// <param name="connectedDoorIndex">The index of the door that is linked to this one.</param>
        /// <param name="lockT">The type of lock that is on this door.</param>
        public Door(ContentManager content, AudioEngine audioEngine, DoorOrientations orient, string roomName, int connectedDoorIndex, Locks lockT)
            : base("Door", content)
        {
            Content = content;
            soundEngine = audioEngine;
            orientation = orient;
            linkedRoom = null;
            linkedRoomName = roomName;
            linkedDoorIndex = connectedDoorIndex;
            lockType = lockT;

            isOpen = false;
            isSolid = true;

            switch (lockType)
            {
                case Locks.Unlocked:
                    animation = Animations.Unlocked;
                    break;
                case Locks.Red:
                    animation = Animations.RedLock;
                    break;
                default:
                    animation = Animations.Unlocked;
                    break;
            }

            currentAnimation = (int)animation + (int)orientation;
        }
示例#2
0
 /// <summary>
 /// Checks for geometric collision with all of the enemies in the room.
 /// </summary>
 /// <param name="room">The room the player is currently in.</param>
 public void DetectEnemyCollisions(Room room)
 {
     foreach (Enemy enemy in room.EnemyArray)
     {
         if (enemy.IsSpawned &&
             (position.Y + collisionYs.Last() >= enemy.Position.Y + enemy.CollisionYs.First()) &&
             (position.Y + collisionYs.First() <= enemy.Position.Y + enemy.CollisionYs.Last()) &&
             (position.X + collisionXs.Last() >= enemy.Position.X + enemy.CollisionXs.First()) &&
             (position.X + collisionXs.First() <= enemy.Position.X + enemy.CollisionXs.Last()))
         {
             if ((position.X + collisionXs.First() <= enemy.Position.X + enemy.CollisionXs.Last()) &&
                 position.X + collisionXs.First() >= enemy.Position.X + enemy.CollisionXs.First())
             {
                 CollideWithEnemy(enemy, XDirection.Left);
                 return;
             }
             else
             {
                 CollideWithEnemy(enemy, XDirection.Right);
                 return;
             }
         }
     }
 }
示例#3
0
 /// <summary>
 /// Loads the linked room in a seperate thread
 /// </summary>
 private void LoadRoom()
 {
     try
     {
         linkedRoom = new Room(linkedRoomName, linkedDoorIndex);
         isRoomLoaded = true;
     }
     catch (Exception e)
     {
         System.Diagnostics.Debug.WriteLine("There was an error loading the room: " + e.Message);
     }
 }
        /// <summary>
        /// Checks to see if the object will walk over a ledge if they move
        /// with their attempted horizontal displacement.
        /// </summary>
        /// <param name="room">The room the object is in.</param>
        /// <returns></returns>
        public bool WillMovePastEdge(Room room)
        {
            int column;

            if (displacementX > 0)
                column = (int)(Position.X + displacementX + collisionXs.Last());
            else if (displacementX < 0)
                column = (int)(Position.X + displacementX + collisionXs.First());
            else
                return false;

            int row = (int)(Position.Y + displacementY + collisionYs.Last() + 1);

            if (row < 0 || row >= room.CollisionMap.Height)
                return false;

            if (room.collisionColors[column + row * room.CollisionMap.Width].R == 0)
                return false;

            foreach (GameObject obj in room.ObjectArray)
            {
                if (obj.IsSolid && obj.IsSpawned)
                {
                    if ((column >= obj.Position.X) && (column <= obj.Position.X + obj.HitBox.Width) &&
                        (row >= obj.Position.Y) && (row <= obj.Position.Y + obj.HitBox.Height))
                        return false;
                }
            }
            return true;
        }
示例#5
0
 /// <summary>
 /// Checks if the player is touching any hazards in the room.
 /// </summary>
 /// <param name="room">The room in which the character is in.</param>
 /// <returns></returns>
 public bool CheckHazards(Room room)
 {
     foreach (GameObject obj in room.EnvironmentArray)
     {
         if (obj.IsHazard)
         {
             if ((position.X + collisionXs.Last() >= obj.Position.X) &&
                 (position.X + collisionXs.First() <= obj.Position.X + obj.HitBox.Width) &&
                 (position.Y + collisionYs.Last() >= obj.Position.Y) &&
                 (position.Y + collisionYs.First() <= obj.Position.Y + obj.HitBox.Height))
                 return true;
         }
     }
     return false;
 }
 /// <summary>
 /// Checks to see if an object is stuck inside of a solid region or object at its
 /// current coordinates, OR if it *will be* stuck if its coordinates are adjusted
 /// by specified amounts in the x and/or y positions.
 /// Non-zero values may be input for dX and/or dY to test for stuckness at the
 /// coordinates equal to the object's coordinates plus the vector (dX, dY).
 /// </summary>
 /// <param name="room">The room in which to test for stuckness</param>
 /// <param name="dX">The value by which to adjust the x-coordinate in the test</param>
 /// <param name="dY">The value by which to adjust the y-coordinate in the test</param>
 /// <returns></returns>
 public virtual bool IsStuck(Room room, int dX, int dY)
 {
     //If dX != 0, it's added to the test x-coordinate
     int CoordinateX = (int)Position.X + dX;
     //If the leftmost collision points are past the left of the map, or
     //if the rightmost collision points are past the right of the map,
     //the object is stuck.
     if (CoordinateX + collisionXs.First() < 0 ||
         CoordinateX + collisionXs.Last() >= room.CollisionMap.Width)
         return true;
     //If dY != 0, it's added to the test y-coordinate
     int CoordinateY = (int)Position.Y + dY;
     foreach (int intY in collisionYs)
     {
         //Collision points above or below the map will not cause stuckness.
         if (CoordinateY + intY >= 0 && CoordinateY + intY < room.CollisionMap.Height)
         {
             foreach (int intX in collisionXs)
             {
                 //Walls/grounds/ceilings are black on the collision map, i.e. the R value is 0
                 if (room.collisionColors[CoordinateX + intX + (CoordinateY + intY) * room.CollisionMap.Width].R == 0)
                     return true;
             }
         }
     }
     foreach (GameObject obj in room.ObjectArray)
     {
         if (obj.IsSolid && obj.IsSpawned && this != obj)
         {
             if ((CoordinateX + collisionXs.First() <= obj.Position.X + obj.HitBox.Width) &&
                 (CoordinateX + collisionXs.Last() >= obj.Position.X) &&
                 (CoordinateY + collisionYs.First() <= obj.Position.Y + obj.HitBox.Height) &&
                 (CoordinateY + collisionYs.Last() >= obj.Position.Y))
             {
                 if (dX == 0 & obj.IsPhysicsObject)
                     riding = (PhysicsObject)obj;
                 return true;
             }
         }
     }
     return false;
 }
        /// <summary>
        /// Tests whether an object that sticks to surfaces will lose contact with all
        /// surfaces if its horizontal position in the room were adjusted by its horizontal
        /// displacement for this frame.
        /// </summary>
        /// <param name="room">The room in which to test for surfaces.</param>
        /// <returns></returns>
        public bool WillLoseSurface(Room room)
        {
            int column = (int)position.X;
            int row = (int)position.Y;

            if (displacementX != 0)
            {
                if (isOnGround)
                {
                    if (CheckGround(room, (int)displacementX, 0))
                        return false;
                    row += collisionYs.Last() + 1;
                }
                else if (ceilingAbove)
                {
                    if (CheckCeiling(room, (int)displacementX, 0))
                        return false;
                    row += collisionYs.First() - 1;
                }
                else
                    return false;

                column += (int)displacementX;

                if (displacementX > 0)
                    column += collisionXs.First() - 1;
                else
                    column += collisionXs.Last() + 1;
            }
            else if (displacementY != 0)
            {
                if (wallOnRight)
                {
                    if (CheckWallRight(room, 0, (int)displacementY))
                        return false;
                    column += collisionXs.Last() + 1;
                }
                else if (wallOnLeft)
                {
                    if (CheckWallLeft(room, 0, (int)displacementY))
                        return false;
                    column += collisionXs.First() - 1;
                }
                else
                    return false;

                row += (int)displacementY;

                if (displacementY > 0)
                    row += collisionXs.First() - 1;
                else
                    row += collisionXs.Last() + 1;
            }
            else
                return false;

            foreach (GameObject obj in room.ObjectArray)
            {
                if (obj.IsSolid && obj.IsSpawned)
                {
                    if ((column >= obj.Position.X) && (column <= obj.Position.X + obj.HitBox.Width) &&
                        (row >= obj.Position.Y) && (row <= obj.Position.Y + obj.HitBox.Height))
                        return false;
                }
            }

            if (room.collisionColors[column + row * room.CollisionMap.Width].R == 0)
                return false;

            return true;
        }
        /// <summary>
        /// Checks to see if the object is touching ground at its current coordinates, OR
        /// if the object *will be* touching ground if its coordinates are adjusted by
        /// specified amounts in the x and/or y directions.
        /// Non-zero values may be input for dX and/or dY to test for ground at the coordinates
        /// equal to the object's coordinates plus the vector (dX, dY).
        /// </summary>
        /// <param name="room">The room in which to test for ground</param>
        /// <param name="dX">The value by which to adjust the x-coordinate in the test</param>
        /// <param name="dY">The value by which to adjust the y-coordinate in the test</param>
        /// <returns></returns>
        public virtual bool CheckGround(Room room, int dX, int dY)
        {
            //row is the y-coordinate just beneath the object's hitbox at its
            //(adjusted) coordinates.
            int row = (int)Position.Y + dY + collisionYs.Last() + 1;
            //All space above or below the map is not considered ground.
            if (row < 0 || row >= room.CollisionMap.Height)
                return false;
            //If the row is on the collision map, do a color test on
            //all collision points in the row:
            int coordinateX = (int)Position.X + dX;
            foreach (int intX in collisionXs)
            {
                //Walls/grounds/ceilings are black on the collision map, i.e. the R value is 0
                if (room.collisionColors[(int)(coordinateX + intX + row * room.CollisionMap.Width)].R == 0)
                    return true;
            }
            //If none of the collision points are in a black region, there is no ground.

            foreach (GameObject obj in room.ObjectArray)
            {
                if (obj.IsSolid && obj.IsSpawned && this != obj)
                {
                    if ((coordinateX + collisionXs.First() <= obj.Position.X + obj.HitBox.Width) &&
                        (coordinateX + collisionXs.Last() >= obj.Position.X) &&
                        (row >= obj.Position.Y) && (row <= obj.Position.Y + obj.HitBox.Height))
                    {
                        obj.StandingOn(objectName);
                        if(obj.IsPhysicsObject)
                            riding = (PhysicsObject)obj;
                        return true;
                    }
                }
            }
            return false;
        }
        /// <summary>
        /// Checks to see if the object is touching a wall on its right side at its current
        /// coordinates, OR if the object *will be* touching a wall if its coordinates are
        /// adjusted by specified amounts in the x and/or y directions.
        /// Non-zero values may be input for dX and/or dY to test for walls at the coordinates
        /// equal to the object's coordinates plus the vector (dX, dY).
        /// </summary>
        /// <param name="room">The room in which to test for a wall</param>
        /// <param name="dX">The value by which to adjust the x-coordinate in the test</param>
        /// <param name="dY">The value by which to adjust the y-coordinate in the test</param>
        /// <returns></returns>
        public virtual bool CheckWallRight(Room room, int dX, int dY)
        {
            //column is the x-coordinate just right of the object's hitbox
            //at its (adjusted) coordinates.
            int column = (int)Position.X + dX + collisionXs.Last() + 1;
            //All space to the right of the map is not considered a wall.
            if (column >= room.CollisionMap.Width)
                return false;
            //If the column is on the collision map, do a color test on
            //all collision points in the column:
            int coordinateY = (int)Position.Y + dY;
            foreach (int intY in collisionYs)
            {
                //All space in the column that is above or below the map will not be considered
                //a wall. But any collision points in the column and on the map *will* be tested.
                //Walls/grounds/ceilings are black on the collision map, i.e. the R value is 0
                if (coordinateY + intY >= 0 && coordinateY + intY < room.CollisionMap.Height &&
                    room.collisionColors[column + (coordinateY + intY) * room.CollisionMap.Width].R == 0)
                    return true;
            }

            foreach (GameObject obj in room.ObjectArray)
            {
                if (obj.IsSolid && obj.IsSpawned && this != obj)
                {
                    if ((coordinateY + collisionYs.First() <= obj.Position.Y + obj.HitBox.Height) &&
                        (coordinateY + collisionYs.Last() >= obj.Position.Y) &&
                        (column >= obj.Position.X) && (column <= obj.Position.X + obj.HitBox.Width))
                        return true;
                }
            }
            //If none of the collision points are in a black region, there is no wall.
            return false;
        }
示例#10
0
        /// <summary>
        /// Switches the current room to the designated room, unloading the old room.
        /// </summary>
        /// <param name="whichRoom">The room to switch to.</param>
        private void SwitchRooms(Room whichRoom)
        {
            oldRoom = currentRoom;
            currentRoom = whichRoom;

            StaticBGM.SwitchMusic(currentRoom.MusicName);
            currentRoom.PlaySoundInstance();

            player.Spawn(currentRoom.SpawnLocation);
            gameHUD.DisplayRoomName(currentRoom.LongName);

            System.Threading.Thread roomDisposeThread = new System.Threading.Thread(DisposeRoom);
            roomDisposeThread.Start();
        }
        /// <summary>
        /// Checks to see that the object is fully grounded: instead of checking that at least
        /// one collision point in the bottom row is sitting on either a collision region of the
        /// map or a solid GameObject, it checks that *each* collision point in the bottom row is
        /// sitting on either a collision region or a solid GameObject.
        /// </summary>
        /// <param name="room">The room in to test for groundedness.</param>
        /// <param name="dX">The value by which to adjust the x-coordinate in the test</param>
        /// <param name="dY">The value by which to adjust the y-coordinate in the test</param>
        /// <returns></returns>
        public bool CheckFullyGrounded(Room room, int dX, int dY)
        {
            int row = (int)Position.Y + dY + collisionYs.Last() + 1;

            if (row < 0 || row >= room.CollisionMap.Height)
                return false;

            bool pointOnSolid = false;

            foreach (int intX in collisionXs)
            {
                int coordinateX = (int)Position.X + dX + intX;

                if (room.collisionColors[coordinateX + row * room.CollisionMap.Width].R == 0)
                    continue;

                pointOnSolid = false;
                foreach (GameObject obj in room.ObjectArray)
                {
                    if (obj.IsSolid && obj.IsSpawned && this != obj)
                    {
                        if ((coordinateX >= obj.Position.X) &&
                            (coordinateX <= obj.Position.X + obj.HitBox.Width) &&
                            (row >= obj.Position.Y) && (row <= obj.Position.Y + obj.HitBox.Height))
                        {
                            pointOnSolid = true;
                            break;
                        }
                    }
                }
                if (!pointOnSolid)
                    return false;
            }
            return true;
        }
示例#12
0
        /// <summary>
        /// Starts a new game, getting rid of the menu, deleting old saves, and opening up the starting room.
        /// </summary>
        private void StartNewGame()
        {
            if (gameMenu != null)
            {
                gameMenu.Dispose();
                gameMenu = null;
            }

            DeleteSave();

            GameResources.RoomSaves = new List<RoomSaveData>();

            StaticBGM.SwitchMusic("Level");

            currentRoom = new Room("StartRoom", -1);
            player = new Player(gameContent, SaveGame, SwitchRooms, DisplayInfoBox);
            player.Spawn(currentRoom.SpawnLocation);
            gameHUD = new HUD(gameContent, player);
            gameHUD.DisplayRoomName(currentRoom.LongName);

            isPaused = false;
            inGame = true;
        }
示例#13
0
        /// <summary>
        /// Loads the previously saved game
        /// </summary>
        private void LoadGame()
        {
            try
            {
                currentStorageDevice = GetStorageDevice();
                using (StorageContainer container = GetStorageContainer(currentStorageDevice))
                {
                    using (Stream stream = container.OpenFile("SaveGame.txt", FileMode.Open))
                    {
                        using (StreamReader sr = new StreamReader(stream))
                        {
                            string line = GameResources.getNextDataLine(sr, "#");
                            currentRoom = new Room(line, -1);
                            int playerHealth = int.Parse(GameResources.getNextDataLine(sr, "#"));
                            bool[] playerItems = new bool[int.Parse(GameResources.getNextDataLine(sr, "#"))];
                            for (int i = 0; i < playerItems.Length; i++)
                                playerItems[i] = bool.Parse(GameResources.getNextDataLine(sr, "#"));

                            RoomSaveData[] roomSaves = new RoomSaveData[int.Parse(GameResources.getNextDataLine(sr, "#"))];

                            for (int i = 0; i < roomSaves.Length; i ++)
                            {
                                roomSaves[i].roomName = GameResources.getNextDataLine(sr, "#");
                                bool[] objects = new bool[int.Parse(GameResources.getNextDataLine(sr, "#"))];
                                for (int j = 0; j < objects.Length; j++)
                                    objects[j] = bool.Parse(GameResources.getNextDataLine(sr, "#"));
                                roomSaves[i].objectsAreSpawned = objects;
                            }

                            GameResources.RoomSaves = new List<RoomSaveData>();
                            foreach (RoomSaveData save in roomSaves)
                                GameResources.RoomSaves.Add(save);

                            player = new Player(gameContent, SaveGame, SwitchRooms, DisplayInfoBox);
                            player.Spawn(currentRoom.SpawnLocation);
                            player.LoadSave(playerHealth, playerItems);
                            gameHUD = new HUD(gameContent, player);

                            isPaused = false;
                            inGame = true;

                            sr.Close();
                        }
                    }

                    StaticBGM.SwitchMusic(currentRoom.MusicName);

                }
            }
            catch (FileNotFoundException e)
            {
                System.Diagnostics.Debug.WriteLine("The save file could not be found: " + e.Message);
                StartNewGame();
            }
        }
示例#14
0
 /// <summary>
 /// Removes the previously loaded room from memory.
 /// </summary>
 private void DisposeRoom()
 {
     if (oldRoom != null)
     {
         oldRoom.Dispose();
         oldRoom = null;
     }
 }
        /// <summary>
        /// Tests to see if an object's intended x- and y-displacements are fully achievable in its
        /// current room and position. Causes a collision and modifies the displacement value if
        /// it would send the object into a collideable surface.
        /// </summary>
        /// <param name="obj">The object to be evaluated.</param>
        /// <param name="room">The room in which the object is located and trying to move.</param>
        /// <param name="time">The amount of time since the last frame.</param>
        public static void Update(PhysicsObject obj, Room room, GameTime time)
        {
            PhysicsObject ridingAtStart = obj.riding;
            float totalTime = (float)(time.ElapsedGameTime.TotalSeconds);
            //All ungrounded, gravity-affected objects will have the displacement caused by
            //gravity in this frame added to their y-displacement.
            if (obj.IsGravityAffected && !obj.IsOnGround)
                obj.DisplacementY = Math.Min(obj.DisplacementY + (GRAVITY / 2) * (totalTime * totalTime), MAX_FALLING_SPEED * totalTime);

            obj.DisplacementX = (float)((int)(obj.DisplacementX));
            obj.DisplacementY = (float)((int)(obj.DisplacementY));

            //If the object will get stuck trying to move the originally intended amount, a collision
            //has occurred. The appropriate velocity & acceleration variables as well as boolean flags
            //will be reset, by calling the appropriate collision function (HitCeiling(), Land(), or
            //HitWall()).
            //Then the intended displacement is decreased by one until the object finds a coordinate
            //at which it will no longer be stuck.
            if (obj.DisplacementY < 0)
            {
                if (obj.IsStuck(room, 0, (int)obj.DisplacementY))
                {
                    obj.HitCeiling();
                    obj.DisplacementY += 1;
                    while (obj.DisplacementY != 0 && obj.IsStuck(room, 0, (int)obj.DisplacementY))
                        obj.DisplacementY += 1;
                }
                if (obj.SticksToSurfaces && obj.DisplacementX == 0)
                {
                    if (obj.WillLoseSurface(room))
                    {
                        while (obj.WillLoseSurface(room))
                            obj.DisplacementY += 1;
                    }
                }
            }
            else if (obj.DisplacementY > 0)
            {
                if (obj.IsStuck(room, 0, (int)obj.DisplacementY))
                {
                    obj.Land();
                    obj.DisplacementY -= 1;
                    while (obj.DisplacementY != 0 && obj.IsStuck(room, 0, (int)obj.DisplacementY))
                        obj.DisplacementY -= 1;
                }
                if (obj.SticksToSurfaces && obj.DisplacementX == 0)
                {
                    if (obj.WillLoseSurface(room))
                    {
                        while (obj.WillLoseSurface(room))
                            obj.DisplacementY -= 1;
                    }
                }
            }

            if (obj.DisplacementX > 0)
            {
                if (obj.IsStuck(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                {
                    obj.CollideRight();
                    obj.DisplacementX -= 1;
                    while (obj.DisplacementX != 0 && obj.IsStuck(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                        obj.DisplacementX -= 1;
                }
                if (!obj.MovesOffEdges && obj.IsOnGround && obj.DisplacementY == 0)
                {
                    if (obj.WillMovePastEdge(room))
                    {
                        obj.VelocityX *= -1;
                        while (obj.WillMovePastEdge(room))
                            obj.DisplacementX -= 1;
                    }
                }
                if (obj.SticksToSurfaces && obj.DisplacementY == 0)
                {
                    if (obj.WillLoseSurface(room))
                    {
                        while (obj.WillLoseSurface(room))
                            obj.DisplacementX -= 1;
                    }
                }
            }
            else if (obj.DisplacementX < 0)
            {
                if (obj.IsStuck(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                {
                    obj.CollideLeft();
                    obj.DisplacementX += 1;
                    while (obj.DisplacementX != 0 && obj.IsStuck(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                        obj.DisplacementX += 1;
                }
                if (!obj.MovesOffEdges && obj.IsOnGround && obj.DisplacementY == 0)
                {
                    if (obj.WillMovePastEdge(room))
                    {
                        obj.VelocityX *= -1;
                        while (obj.WillMovePastEdge(room))
                            obj.DisplacementX += 1;
                    }
                }
                if (obj.SticksToSurfaces && obj.DisplacementY == 0)
                {
                    if (obj.WillLoseSurface(room))
                    {
                        while (obj.WillLoseSurface(room))
                            obj.DisplacementX += 1;
                    }
                }
            }
            else if (obj.DisplacementX == 0 && obj.DisplacementY == 0)
            {
                if (obj.IsStuck(room, 0, 0))
                {
                    if (obj.WallOnLeft && !obj.WallOnRight)
                        obj.DisplacementX += STUCK_OBJ_DISPLACEMENT;
                    else if (obj.WallOnRight && !obj.WallOnLeft)
                        obj.DisplacementX -= STUCK_OBJ_DISPLACEMENT;
                }
            }

            //Even if a displacement value goes unchanged in the above test, it's still possible that the object
            //will (not) have a wall beside or ground beneath them after moving their full displacements. This last
            //test checks to see if this is the case, and changes the appropriate boolean flags accordingly.
            //If the object is touching a floor in its new position, the appropriate collision-causing function
            //is called.
            //If an object was airborne at the beginning of the frame and is still airborne, its y-velocity
            //is increased by the acceleration due to gravity.
            //If it's determined that the object is now in the air, it will become airborne.

            if (!obj.WallOnLeft)
            {
                if (obj.CheckWallLeft(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                    obj.CollideLeft();
            }
            else
            {
                if (!obj.CheckWallLeft(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                    obj.WallOnLeft = false;
            }

            if (!obj.WallOnRight)
            {
                if (obj.CheckWallRight(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                    obj.CollideRight();
            }
            else
            {
                if (!obj.CheckWallRight(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                    obj.WallOnRight = false;
            }

            if (!obj.IsOnGround)
            {
                if (obj.CheckGround(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                    obj.Land();
                else if (obj.IsGravityAffected)
                    obj.VelocityY = Math.Min(obj.VelocityY + GRAVITY * totalTime, MAX_FALLING_SPEED);
            }
            else
            {
                if (!obj.CheckGround(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                    obj.LeaveGround();
            }

            if (!obj.CeilingAbove)
            {
                if (obj.CheckCeiling(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                    obj.HitCeiling();
            }
            else
            {
                if (!obj.CheckCeiling(room, (int)obj.DisplacementX, (int)obj.DisplacementY))
                    obj.LeaveCeiling();
            }

            if ((obj.riding != null) && (obj.riding == ridingAtStart))
            {
                obj.DisplacementX += ridingAtStart.DisplacementX;
                obj.DisplacementY += ridingAtStart.DisplacementY;
            }
        }
示例#16
0
        /// <summary>
        /// Extension of PhysicsObject.IsStuckAt() for Enemies. Adds additional check for
        /// collisions with other enemy objects and walking off ledges before the other checks.
        /// </summary>
        /// <param name="room">The room the enemy is located in.</param>
        /// <param name="dX">An optional amount by which to adjust the Enemy's x-position for the test.</param>
        /// <param name="dY">An optional amount by which to adjust the Enemy's y-position for the test.</param>
        /// <returns></returns>
        public override bool IsStuck(Room room, int dX, int dY)
        {
            if (bumpsOtherEnemies)
            {
                for (int i = 0; i < room.EnemyArray.Length; i++)
                {
                    if (!room.EnemyArray[i].BumpsOtherEnemies || !room.EnemyArray[i].isSpawned)
                        continue;

                    if (this == room.EnemyArray[i])
                        continue;

                    if ((position.Y + dY + collisionYs.Last() >= room.EnemyArray[i].Position.Y + room.EnemyArray[i].collisionYs.First()) &&
                        (position.Y + dY + collisionYs.First() <= room.EnemyArray[i].Position.Y + room.EnemyArray[i].collisionYs.Last()) &&
                        (position.X + dX + collisionXs.Last() >= room.EnemyArray[i].Position.X + room.EnemyArray[i].collisionXs.First()) &&
                        (position.X + dX + collisionXs.First() <= room.EnemyArray[i].Position.X + room.EnemyArray[i].collisionXs.Last()))
                        return true;
                }
            }

            return base.IsStuck(room, dX, dY);
        }