private RoomPositionInfo GetSpawnLocationFromConnection(Room lastRoom, Room.RoomConnection connection, Room nextRoom)
    {
        Vector2 result = lastRoom.transform.position;
        Vector2 mapPos = lastRoom.mapPosition;

        RoomPositionInfo roomPosInfo = new RoomPositionInfo();

        switch (connection)
        {
        case Room.RoomConnection.Top:
            result += new Vector2(0f, lastRoom.roomSize.y) + nextRoom.roomOffset - lastRoom.roomOffset;
            mapPos += new Vector2(0f, 60f);
            break;

        case Room.RoomConnection.Bottom:
            result -= new Vector2(0f, lastRoom.roomSize.y) - nextRoom.roomOffset + lastRoom.roomOffset;
            mapPos -= new Vector2(0f, 60f);
            break;

        case Room.RoomConnection.Left:
            result -= new Vector2(lastRoom.roomSize.x, 0f) - nextRoom.roomOffset + lastRoom.roomOffset;
            mapPos -= new Vector2(60f, 0f);
            break;

        case Room.RoomConnection.Right:
            result += new Vector2(lastRoom.roomSize.x, 0f) + nextRoom.roomOffset - lastRoom.roomOffset;
            mapPos += new Vector2(60f, 0f);
            break;
        }

        for (int i = 0; i < activeRooms.Count; i++)
        {
            if (activeRooms[i].IsPointInRoom(result) || activeRooms[i].DoesRoomOverlap(nextRoom.roomSize, result))
            {
                //Debug.Log(lastRoom.gameObject.name + " is inside " + activeRooms[i].gameObject.name);
                roomPosInfo.ResetPos();
                //return Vector2.zero;
                return(roomPosInfo);
            }
        }

        roomPosInfo.spawnPosition = result;
        roomPosInfo.mapPosition   = mapPos;

        return(roomPosInfo);
    }
    private Room GetRandomRoom(Room.RoomConnection connection = Room.RoomConnection.None)
    {
        switch (connection)
        {
        case Room.RoomConnection.Top:
            return(roomCollection.topRooms[GetRandomRoomIndex(roomCollection.topRooms)]);

        case Room.RoomConnection.Bottom:
            return(roomCollection.bottomRooms[GetRandomRoomIndex(roomCollection.bottomRooms)]);

        case Room.RoomConnection.Left:
            return(roomCollection.leftRooms[GetRandomRoomIndex(roomCollection.leftRooms)]);

        case Room.RoomConnection.Right:
            return(roomCollection.rightRooms[GetRandomRoomIndex(roomCollection.rightRooms)]);
        }


        return(null);
    }
    private Room.RoomConnection GetOppositeConnection(Room.RoomConnection connection)
    {
        switch (connection)
        {
        case Room.RoomConnection.Top:
            return(Room.RoomConnection.Bottom);

        case Room.RoomConnection.Bottom:
            return(Room.RoomConnection.Top);

        case Room.RoomConnection.Left:
            return(Room.RoomConnection.Right);

        case Room.RoomConnection.Right:
            return(Room.RoomConnection.Left);

        default:
            return(Room.RoomConnection.None);
        }
    }
    public void CreateRoom(Room lastRoom = null, int roomsToMake = 10)
    {
        Vector2    spawnLocation = Vector2.zero;
        Vector2    mapLocation   = Vector2.zero;
        GameObject newRoomGameObject;
        Room       newRoom = null;

        //Debug.Log("Making " + roomsToMake + " rooms");

        if (lastRoom == null)
        {
            spawnLocation = Vector2.zero;

            newRoomGameObject = Instantiate(roomCollection.startRooms[GetRandomRoomIndex(roomCollection.startRooms)].gameObject, spawnLocation, Quaternion.identity) as GameObject;
            string numberName1 = newRoomGameObject.name + " " + activeRooms.Count;
            newRoomGameObject.name = numberName1;

            newRoom             = newRoomGameObject.GetComponent <Room>();
            newRoom.mapPosition = mapLocation;
            newRoom.roomType    = Room.RoomType.Start;

            newRoom.Initialize();

            activeRooms.Add(newRoom);

            if (roomsToMake > 0)
            {
                CreateRoom(newRoom, roomsToMake - 1);
            }

            return;
        }

        Room.RoomConnection targetConnection   = lastRoom.GetRandomFreeConnection();
        Room.RoomConnection oppositeConnection = GetOppositeConnection(targetConnection);

        if (targetConnection == Room.RoomConnection.None)
        {
            //Debug.Log(lastRoom.gameObject.name + " has no free connections");
            //Debug.Log("Restarting with " + roomsToMake + " ropms");
            RestartRoomCreation(GetRandomRoomWithFreeConnections(), roomsToMake);
            return;
        }


        Room             nextRoom    = GetRandomRoom(oppositeConnection);
        RoomPositionInfo roomPosInfo = GetSpawnLocationFromConnection(lastRoom, targetConnection, nextRoom);

        spawnLocation = roomPosInfo.spawnPosition;
        mapLocation   = roomPosInfo.mapPosition;


        if (spawnLocation == Vector2.zero)
        {
            //Debug.Log("Map ran into itself");
            //Debug.Log("Restarting with " + roomsToMake + " ropms");
            RestartRoomCreation(GetRandomRoomWithFreeConnections(), roomsToMake);
            return;
        }

        newRoomGameObject = Instantiate(nextRoom.gameObject, spawnLocation, Quaternion.identity) as GameObject;
        string numberName = newRoomGameObject.name + " " + activeRooms.Count;

        newRoomGameObject.name = numberName;

        newRoom             = newRoomGameObject.GetComponent <Room>();
        newRoom.mapPosition = mapLocation;
        newRoom.occupiedConnections.Add(oppositeConnection);
        lastRoom.occupiedConnections.Add(targetConnection);

        newRoom.Initialize();

        activeRooms.Add(newRoom);

        if (roomsToMake > 0)
        {
            //Debug.Log(roomsToMake + " more rooms to make");
            CreateRoom(newRoom, roomsToMake - 1);
        }
    }
 private Room.RoomConnection DrawListOfRoomConnections(List <Room.RoomConnection> list, int index)
 {
     Room.RoomConnection result = EditorHelper.EnumPopup("Entry", list[index]);
     return(result);
 }