Esempio n. 1
0
    public override LevelData Generate(LevelDefenition def)
    {
        LevelData data = base.Generate(def);

        var clearTiles = new List <Vector2Int>();

        for (int y = 0; y < data.size.y; y++)
        {
            for (int x = 0; x < data.size.x; x++)
            {
                if (y > 0 && y < data.size.y - 1 && x > 0 && x < data.size.x - 1)
                {
                    data.tiles[x, y] = Tile.Floor;
                    clearTiles.Add(new Vector2Int(x, y));
                }
                else
                {
                    data.tiles[x, y] = Tile.Wall;
                }
            }
        }

        data.entrance = new Vector2Int(data.size.x / 2, 0);
        data.tiles[data.entrance.x, data.entrance.y] = Tile.Entrance;

        data.tiles[data.size.x / 2, data.size.y - 1] = Tile.Exit;

        clearTiles.Remove(data.entrance);
        clearTiles.Remove(data.exit);

        data.mobSpawns = GenerateSpawns(clearTiles);

        return(data);
    }
Esempio n. 2
0
    public virtual LevelData Generate(LevelDefenition def)
    {
        var sizeX = Random.Range(def.minSize.x, def.maxSize.x);
        var sizeY = Random.Range(def.minSize.y, def.maxSize.y);

        return(new LevelData
        {
            size = new Vector2Int(sizeX, sizeY),
            style = def.styles[Random.Range(0, def.styles.Length)],
            tiles = new Tile[sizeX, sizeY],
        });
    }
Esempio n. 3
0
    public override LevelData Generate(LevelDefenition def)
    {
        var data = base.Generate(def);

        int walks        = 0;
        int cleared      = 0;
        int tilesToClear = (int)(Random.Range(MIN_CLEAR, MAX_CLEAR) * data.size.x * data.size.y);

        Vector2Int pos = data.size / 2;

        data.entrance = pos;

        // Fill with Walls;
        for (int y = 0; y < data.size.y; y++)
        {
            Parallel.For(0, data.size.x, (x) =>
            {
                data.tiles[x, y] = Tile.Wall;
            });
        }

        var clearTiles = new List <Vector2Int>();

        // Walk the grid
        while (walks < MAX_WALK && cleared < tilesToClear)
        {
            bool alreadyCleared = data.tiles[pos.x, pos.y] == Tile.Floor;

            data.tiles[pos.x, pos.y] = Tile.Floor;

            if (!alreadyCleared)
            {
                cleared++;
                clearTiles.Add(pos);
            }

            // Walk in random direction.
            bool horizontal = Random.value > 0.5f;
            var  direction  = new Vector2Int(horizontal ? 1 : 0, horizontal ? 0 : 1);
            if (Random.value > 0.5f)
            {
                direction *= -1;
            }

            var newPos = pos + direction;

            // Bounds check
            if (newPos.x > 0 &&
                newPos.x < data.size.x - 1 &&
                newPos.y > 0 &&
                newPos.y < data.size.y - 1)
            {
                pos = newPos;
            }

            walks++;
        }

        data.exit = pos;

        data.tiles[data.entrance.x, data.entrance.y] = Tile.Entrance;
        data.tiles[data.exit.x, data.exit.y]         = Tile.Exit;

        clearTiles.Remove(data.exit);
        clearTiles.Remove(data.entrance);

        data.mobSpawns = GenerateSpawns(clearTiles);

        return(data);
    }