//please use settings in real generation, for dummy generator it can be skipped
    //[Inject]
    //DMISettingsInstaller.LevelSettings _settings;

    //mock data for room generator
    public IEnumerable <RoomMetaData> generate(int seed, ref IntVector2 levelSize)
    {
        if ((levelSize.x < 20) || (levelSize.y < 20))
        {
            throw new NotSupportedException("Can mock only on 20x20 or greater map");
        }

        IList <RoomMetaData> rooms = new List <RoomMetaData>();

        RoomMetaData room1 = new RoomMetaData {
            position      = new IntVector2(2, 2),
            size          = new IntVector2(5, 6),
            doorLocations = new List <IntVector2>
            {
                new IntVector2(4, 4)
            },
            hasExit  = false,
            hasStart = true
        };

        RoomMetaData room2 = new RoomMetaData
        {
            position      = new IntVector2(7, 4),
            size          = new IntVector2(6, 8),
            doorLocations = new List <IntVector2>
            {
                new IntVector2(0, 2),
                new IntVector2(2, 7)
            },
            hasExit  = true,
            hasStart = false
        };

        RoomMetaData room3 = new RoomMetaData
        {
            position      = new IntVector2(8, 12),
            size          = new IntVector2(4, 4),
            doorLocations = new List <IntVector2>
            {
                new IntVector2(1, 0)
            },
            hasExit  = false,
            hasStart = false
        };

        rooms.Add(room1);
        rooms.Add(room2);
        rooms.Add(room3);
        return(rooms);
    }
Example #2
0
        private List <Room> CreateRooms(List <MapArea> area)
        {
            List <Room> rooms = new List <Room>();

            RoomMetaData roomsMetaData = new RoomMetaData();

            for (int i = 0; i < area.Count; i++)
            {
                int roomX      = Random.Range(area[i].X + 3, area[i].X + 8);
                int roomZ      = Random.Range(area[i].Z + 3, area[i].Z + 8);
                int roomWidth  = Random.Range(roomsMetaData.MinimumRoomWidth, roomsMetaData.MaximumRoomWidth);
                int roomHeight = Random.Range(roomsMetaData.MinimumRoomHeight, roomsMetaData.MaximumRoomHeight);

                Room newRoom = new Room(roomX, roomZ, roomWidth, roomHeight);

                rooms.Add(newRoom);
            }

            return(rooms);
        }
    public IEnumerable <RoomMetaData> generate(int seed, ref IntVector2 levelSize)
    {
        pathCount          = _settings.mapModelPathCount;
        modelRoomCount     = _settings.mapModelRoomCount;
        ModelRoom.sizeMaxX = _settings.roomsSettings.maxRoomSizeX;
        ModelRoom.sizeMaxY = _settings.roomsSettings.maxRoomSizeY;
        ModelRoom.sizeMinX = _settings.roomsSettings.minRoomSizeX;
        ModelRoom.sizeMinY = _settings.roomsSettings.minRoomSizeY;



        Random.InitState(seed);;
        List <ModelRoom>     MapModelRoomList = generateMapModelRoomList();
        IList <RoomMetaData> rooms            = new List <RoomMetaData>();

        IntVector2 maxPosition = new IntVector2(0, 0);
        IntVector2 minPosition = new IntVector2(0, 0);

        foreach (ModelRoom modelRoom in MapModelRoomList)
        {
            if (maxPosition.x < modelRoom.rightX)
            {
                maxPosition.x = modelRoom.rightX;
            }
            if (maxPosition.y < modelRoom.topY)
            {
                maxPosition.y = modelRoom.topY;
            }
            if (minPosition.x > modelRoom.leftX)
            {
                minPosition.x = modelRoom.leftX;
            }
            if (minPosition.y > modelRoom.bottomY)
            {
                minPosition.y = modelRoom.bottomY;
            }
        }

        levelSize.x = maxPosition.x - minPosition.x + 1;
        levelSize.y = maxPosition.y - minPosition.y + 1;

        foreach (ModelRoom modelRoom in MapModelRoomList)
        {
            RoomMetaData newRoom = new RoomMetaData();
            newRoom.position.x = modelRoom.leftX - minPosition.x;
            newRoom.position.y = modelRoom.bottomY - minPosition.y;
            newRoom.size.x     = modelRoom.rightX - modelRoom.leftX + 1;
            newRoom.size.y     = modelRoom.topY - modelRoom.bottomY + 1;

            List <IntVector2> doorList = new List <IntVector2>();
            foreach (ModelDoor door in modelRoom.doors)
            {
                doorList.Add(new IntVector2((int)door.startPosition.x - modelRoom.leftX, (int)door.startPosition.y - modelRoom.bottomY));
            }
            newRoom.doorLocations = doorList;

            if (modelRoom == startRoom)
            {
                newRoom.hasStart = true;
            }
            if (modelRoom == endRoom)
            {
                newRoom.hasExit = true;
            }
            rooms.Add(newRoom);
        }

        return(rooms);
    }