示例#1
0
        public void generateRoom(Vector3 loc, int roomNum)
        {
            Vector2 roomCenter = RoomUtilities.CalculateRoomCenter(loc);

            background.Add(new ExteriorSprite(batch, exterior, roomCenter, SpriteUtilities.BackgroundLayer));
            background.Add(new ExteriorSprite(batch, exterior2, roomCenter, SpriteUtilities.TopBackgroundLayer));
            background.Add(new InteriorSprite(batch, interior, RoomUtilities.INTERIOR_TEXTURE_ROWS, RoomUtilities.INTERIOR_TEXTURE_COLS, roomCenter, roomNum));
            foreach (Rectangle rec in RoomUtilities.GetWallRectangles(loc))
            {
                walls.Add(new Wall(rec));
            }
        }
示例#2
0
        public void ParseXML(String filename)
        {
            String    workingDirectory = Directory.GetParent(Environment.CurrentDirectory).Parent.Parent.FullName;
            XDocument doc = XDocument.Load(workingDirectory + "/" + filename);
            XElement  map = XElement.Load(workingDirectory + "/" + filename);

            XName roomName = XName.Get("room", doc.Root.Name.NamespaceName);

            foreach (XElement room in map.Elements(roomName))
            {
                Room currentRoom;

                XName num       = XName.Get("number", doc.Root.Name.NamespaceName);
                XName sprite    = XName.Get("sprite", doc.Root.Name.NamespaceName);
                int   spriteNum = Int32.Parse(room.Element(sprite).Value);

                Vector3 roomTup = RoomUtilities.ConvertToVector3(room.Element(num).Value);
                if (roomTup.Z % 2 == 0)
                {
                    MiniMapConstants.RoomListZ0.Add(roomTup);
                }

                currentRoom = new Room(roomTup, spriteNum);

                itemParser.ParseItems(currentRoom, room, doc);
                enemyParser.ParseEnemies(currentRoom, room, doc);
                trapParser.ParseTraps(currentRoom, room, doc);
                npcParser.ParseNPCs(currentRoom, room, doc);
                blockParser.ParseBlocks(currentRoom, room, doc);
                doorParser.ParseDoors(currentRoom, room, doc);
                conditionParser.ParseCondtions(currentRoom, room, doc);
                spawnerParser.ParseSpawners(currentRoom, room, doc);

                roomHandler.rooms.Add(roomTup, currentRoom);
            }

            MiniMapConstants.RoomListZ0.Remove(new Vector3(roomHandler.currentRoom.X, roomHandler.currentRoom.Y, roomHandler.currentRoom.Z));
        }
示例#3
0
 public void generateRoomWall(Vector2 blockLoc)
 {
     walls.Add(new Wall(RoomUtilities.calculateRoomBlockWall(blockLoc)));
 }
示例#4
0
        public void generateItemRoom(Vector3 loc)
        {
            Vector2 roomCenter = RoomUtilities.CalculateRoomCenter(loc);

            background.Add(new ExteriorSprite(batch, itemRoom, roomCenter, SpriteUtilities.BackgroundLayer));
        }
示例#5
0
        public void LoadNewRoom(Vector3 newPos, IDoor entranceDoor)
        {
            if (this.currentRoom.Z != newPos.Z && newPos.Z >= 0)
            {
                DungeonMask.Instance.LoadNextMask(((int)newPos.Z) / 2);
            }

            Room    newRoom       = rooms.GetValueOrDefault(newPos);
            Vector2 convertedRoom = RoomUtilities.ConvertVector(newPos);

            if (currentRoom.Z == newPos.Z && startComplete)
            {
                camera.SmoothMoveCamera(convertedRoom, RoomUtilities.CAMERA_CYCLES);
            }
            else
            {
                camera.MoveCamera(convertedRoom, new Vector2(ROOM_WIDTH, ROOM_HEIGHT));
            }

            List <IItem> oldItems = rooms.GetValueOrDefault(currentRoom).Items;

            RoomItems.Instance.LoadNewRoom(ref oldItems, newRoom.Items);
            rooms.GetValueOrDefault(currentRoom).Items = oldItems;

            List <IEntity> oldEnemies = rooms.GetValueOrDefault(currentRoom).Enemies;

            RoomEnemies.Instance.LoadNewRoom(ref oldEnemies, newRoom.Enemies, game);
            rooms.GetValueOrDefault(currentRoom).Enemies = oldEnemies;

            List <ITrap> oldTraps = rooms.GetValueOrDefault(currentRoom).Traps;

            RoomTraps.Instance.LoadNewRoom(ref oldTraps, newRoom.Traps, game);
            rooms.GetValueOrDefault(currentRoom).Traps = oldTraps;

            List <INPC> oldNPCs = rooms.GetValueOrDefault(currentRoom).NPCs;

            RoomNPCs.Instance.LoadNewRoom(ref oldNPCs, newRoom.NPCs);
            rooms.GetValueOrDefault(currentRoom).NPCs = oldNPCs;

            List <IBlock> oldBlocks = rooms.GetValueOrDefault(currentRoom).Blocks;

            RoomBlocks.Instance.LoadNewRoom(ref oldBlocks, newRoom.Blocks);
            rooms.GetValueOrDefault(currentRoom).Blocks = oldBlocks;

            List <IDoor> oldDoors = rooms.GetValueOrDefault(currentRoom).Doors;

            RoomDoors.Instance.LoadNewRoom(ref oldDoors, newRoom.Doors);
            rooms.GetValueOrDefault(currentRoom).Doors = oldDoors;

            List <ISpawner> oldSpawners = rooms.GetValueOrDefault(currentRoom).Spawners;

            RoomSpawners.Instance.LoadNewRoom(ref oldSpawners, newRoom.Spawners);
            rooms.GetValueOrDefault(currentRoom).Spawners = oldSpawners;

            RoomConditions.Instance.LeaveRoom();
            List <ICondition> oldConditions = rooms.GetValueOrDefault(currentRoom).Conditions;

            RoomConditions.Instance.LoadNewRoom(ref oldConditions, newRoom.Conditions);
            rooms.GetValueOrDefault(currentRoom).Conditions = oldConditions;
            RoomConditions.Instance.EnterRoom();

            RoomProjectiles.Instance.Reset();

            currentRoom = newPos;
            rooms.GetValueOrDefault(newPos).SetToVisited();

            roomTransitionManager.StartTransitionManager(entranceDoor);
        }