source: 2012/27/DenisZ/TheDungeonGame/TheDungeonGame/TheDungeonGame/LevelGenerator.cs @ 3596

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Jypeli;
using MathHelper;

namespace Rooms
{
  public class LevelGenerator
    {
        private double width, height;
        private int roomAmountHor, roomAmountVert;
        private TheDungeonGame game;
        private Room[,] rooms;
        private List<Room> roomList = new List<Room>();
        public int level = 1;
        private int roomsPlaced = 0;
        private int roomAmount = 0;

        public LevelGenerator(TheDungeonGame game, Vector size, Vector roomamount)
        {
            this.game = game;
            width = size.X;
            height = size.Y;
            roomAmountHor = (int)roomamount.X;
            roomAmountVert = (int)roomamount.Y;

            rooms = new Room[roomAmountHor, roomAmountVert];
        }

        public Vector getGridPos(Vector pos)
        {
            double gridPosX = pos.X - width / 2;
            double gridPosY = pos.Y + height / 2;

            int x = (int)(gridPosX / TheDungeonGame.ROOMWIDTH);
            int y = (int)(gridPosY / TheDungeonGame.ROOMHEIGHT);

            return new Vector(x, y);
        }

        public Vector CenterRoom
        {
            get
            {
                return new Vector(roomAmountHor / 2, roomAmountVert / 2);
            }
        }

        public void initDungeon()
        {
            foreach (Room room in roomList)
            {
                room.initRoom();
            }
        }

        public void buildDungeon()
        {
            foreach (Room room in roomList)
            {
                room.buildLevel();
            }
        }

        public void destroyDungeon()
        {
            foreach (Room room in roomList)
            {
                room.destroyLevel();
            }
            roomAmount = 0;
            roomsPlaced = 0;
        }

        public void generateRandomLevel(int minRooms, int maxRooms)
        {
            roomAmount = RandomGen.NextInt(minRooms, maxRooms);
            Room lastRoom = null;

            for (int room = 0; room < roomAmount; room++)
            {
                if (room == 0)
                {
                    lastRoom = new EmptyRoom(game, VecMath.mul(CenterRoom, new Vector(TheDungeonGame.ROOMWIDTH + TheDungeonGame.ROOMTHICKNESS, -TheDungeonGame.ROOMHEIGHT - TheDungeonGame.ROOMTHICKNESS)), TheDungeonGame.roomSize, TheDungeonGame.ROOMTHICKNESS);
                    placeRoomAt(lastRoom, (int)CenterRoom.X, (int)CenterRoom.Y);
                    continue;
                }

                Room randomRoom = getRandomRoom();
                int checkedSides = 0;
                bool[] sideChecked = new bool[4];

                while (checkedSides < 4)
                {
                    int dir = RandomGen.NextInt(4);
                    if (sideChecked[dir])
                    {
                        checkedSides++;
                        continue;
                    }
                    else
                    {
                    //    checkedSides++;
                        sideChecked[dir] = true;
                    }

                    if (tryCreateRoom(dir, VecMath.add(lastRoom.PosOnGrid, RoomDirection.getOffsetFromDir(dir)), lastRoom))
                    {
                        lastRoom = currentRoom;
                        roomsPlaced++;
                        break;
                    }
                }

            }
        }

        private Room currentRoom;
        private bool tryCreateRoom(int dir, Vector pos, Room lastRoom)
        {
            if (getRoomFromDirection(lastRoom, dir) != null) return false;

            if (roomsPlaced == roomAmount-5)
            {
                currentRoom = RoomCreator.createRoom(game, VecMath.mul(pos, new Vector(TheDungeonGame.ROOMWIDTH + TheDungeonGame.ROOMTHICKNESS, -TheDungeonGame.ROOMHEIGHT - TheDungeonGame.ROOMTHICKNESS)), TheDungeonGame.roomSize, TheDungeonGame.ROOMTHICKNESS, 7);
                return placeRoomAt(currentRoom, (int)pos.X, (int)pos.Y);
            }

            currentRoom = RoomCreator.createRoom(game, VecMath.mul(pos, new Vector(TheDungeonGame.ROOMWIDTH + TheDungeonGame.ROOMTHICKNESS, -TheDungeonGame.ROOMHEIGHT - TheDungeonGame.ROOMTHICKNESS)), TheDungeonGame.roomSize, TheDungeonGame.ROOMTHICKNESS, RandomGen.NextInt(6)+1);

            return placeRoomAt(currentRoom, (int)pos.X, (int)pos.Y);
        }

        public bool placeRoomAt(Room room, int x, int y)
        {
            if (!isValidPos(x, y) || getRoomAt(x, y) != null) return false;
            room.PosOnGrid = new Vector(x, y);
            rooms[x, y] = room;
            roomList.Add(room);
            return true;
        }

        public Room getRoomAt(int x, int y)
        {
            if (!isValidPos(x, y)) return null;
            return rooms[x, y];
        }

        public Room getRoomAt(Vector pos)
        {
            return getRoomAt((int)pos.X, (int)pos.Y);
        }

        public Room getRoomFromDirection(Room source, int dir)
        {
            int roomX = (int)source.PosOnGrid.X;
            int roomY = (int)source.PosOnGrid.Y;

            Vector roomPos = VecMath.add(source.PosOnGrid, RoomDirection.getOffsetFromDir(dir));
            return getRoomAt((int)roomPos.X, (int)roomPos.Y);
        }

        public Room getRandomRoom()
        {
            if (roomList.Count == 0) throw new InvalidOperationException("The List is empty!");
            return roomList[RandomGen.NextInt(roomList.Count)];
        }

        private bool isValidPos(int x, int y)
        {
            return !(x >= roomAmountHor || x < 0 || y >= roomAmountVert || y < 0);
        }


    }
}