GDScript Procedural Generation Practice

Every tile-based generator follows the same pattern:

1. Fill the grid with walls. TileMapLayer starts solid
2. Carve floors using an algorithm (walk, automata, partition, or noise)
3. Verify connectivity with flood fill so the player can reach everything
4. Place entities by spawning the player, enemies, and items on valid floor tiles

The difference between algorithms is step 2. Everything else is shared infrastructure you write once.

Use RandomNumberGenerator for map generation instead of scattering randf() and randi() across your generator. Explicit seeds make bugs reproducible and let you offer daily seeds or shareable runs.

# Shared pattern: fill grid with walls, then carve
func fill_with_walls() -> void:
    for x in range(width):
        for y in range(height):
            ground_layer.set_cell(Vector2i(x, y), 0, WALL_ATLAS)

A random walker starts at the center and stumbles around, carving floor tiles wherever it steps. The result is an organic cave with winding passages.

const DIRECTIONS: Array[Vector2i] = [
    Vector2i.UP, Vector2i.DOWN, Vector2i.LEFT, Vector2i.RIGHT
]

func drunkard_walk(rng: RandomNumberGenerator, target_coverage: float) -> void:
    var pos := Vector2i(width / 2, height / 2)
    var total_cells := width * height
    var carved := 0

    while float(carved) / total_cells < target_coverage:
        if ground_layer.get_cell_source_id(pos) != FLOOR_SOURCE:
            ground_layer.set_cell(pos, 0, FLOOR_ATLAS)
            carved += 1
        var dir := DIRECTIONS[rng.randi() % DIRECTIONS.size()]
        pos = (pos + dir).clamp(Vector2i.ONE, Vector2i(width - 2, height - 2))

Key insight: Connectivity is free because the walker never lifts off the grid. Every carved tile is reachable from every other carved tile. No flood fill needed.

Build this yourself with the Drunkard's Walk tutorial →

Start with random noise (~45% floor, ~55% walls), then repeatedly smooth it with the 4-5 rule: a cell becomes a wall if 5 or more of its 8 neighbors are walls.

func cellular_automata(rng: RandomNumberGenerator, iterations: int) -> void:
    # Step 1: Random fill (~45% become floor, rest stay as walls)
    for x in range(1, width - 1):
        for y in range(1, height - 1):
            if rng.randf() < 0.45:
                ground_layer.set_cell(Vector2i(x, y), 0, FLOOR_ATLAS)

    # Step 2: Smooth with 4-5 rule
    for i in range(iterations):
        var snapshot := {}  # Read from snapshot, write to live grid
        for x in range(width):
            for y in range(height):
                var pos := Vector2i(x, y)
                snapshot[pos] = ground_layer.get_cell_source_id(pos)

        for x in range(1, width - 1):
            for y in range(1, height - 1):
                var pos := Vector2i(x, y)
                var walls := count_wall_neighbors(snapshot, pos)
                if walls >= 5:
                    ground_layer.set_cell(pos, 0, WALL_ATLAS)
                else:
                    ground_layer.set_cell(pos, 0, FLOOR_ATLAS)

Critical: You must read from a snapshot and write to the live grid (double-buffering). Reading and writing the same grid in-place corrupts the neighbor counts.

Warning: Cellular automata can produce disconnected chambers. Run flood fill afterward to keep only the largest connected region.

Build this yourself with the Cellular Automata tutorial →

Binary Space Partitioning recursively splits a rectangle into halves, places rooms inside the smallest partitions (leaves), and connects siblings with corridors.

func bsp_split(rect: Rect2i, depth: int, rng: RandomNumberGenerator) -> void:
    if rect.size.x < MIN_PARTITION * 2 and rect.size.y < MIN_PARTITION * 2:
        place_room(rect, rng)
        return

    var split_h := rect.size.x < rect.size.y  # Split the longer axis
    if split_h:
        var split_y := rng.randi_range(rect.position.y + MIN_PARTITION,
                                       rect.end.y - MIN_PARTITION)
        var top := Rect2i(rect.position, Vector2i(rect.size.x, split_y - rect.position.y))
        var bottom := Rect2i(Vector2i(rect.position.x, split_y),
                             Vector2i(rect.size.x, rect.end.y - split_y))
        bsp_split(top, depth + 1, rng)
        bsp_split(bottom, depth + 1, rng)
        connect_rooms(top, bottom)
    else:
        # Vertical split (similar logic)
        pass

Connectivity guarantee: The binary tree structure means every room connects to its sibling. No flood fill needed. Corridors follow the tree.

Build this yourself with the BSP Dungeons tutorial →

Godot's built-in FastNoiseLite generates smooth terrain. Threshold the noise into land and water, apply distance falloff to shape an island, then flood fill to remove disconnected landmasses.

func noise_terrain(rng: RandomNumberGenerator) -> void:
    var noise := FastNoiseLite.new()
    noise.noise_type = FastNoiseLite.TYPE_SIMPLEX_SMOOTH
    noise.frequency = 0.05
    noise.fractal_octaves = 4
    noise.seed = rng.randi()

    var center := Vector2(width / 2.0, height / 2.0)
    var max_dist := center.length()

    for x in range(width):
        for y in range(height):
            var value := noise.get_noise_2d(float(x), float(y))
            # Distance falloff: edges become water
            var dist := Vector2(x, y).distance_to(center) / max_dist
            value -= dist * 1.2

            if value > -0.1:
                ground_layer.set_cell(Vector2i(x, y), 0, FLOOR_ATLAS)

Tip: Lower frequency = larger landmasses. Higher fractal_octaves = more fine detail. Apply distance falloff before thresholding so edges always become water.

FastNoiseLite caveat: most noise types stay in the [-1, 1] range, but some cellular noise variants can exceed 1.0. If you swap noise types, retune your threshold instead of assuming the same cutoff still works.

Warning: Noise terrain often produces disconnected islands. Always run flood fill to keep only the largest connected region and remove floating chunks.

Build this yourself with the Noise Terrain tutorial →

Cellular automata and noise terrain often create disconnected pockets. Flood fill solves that by starting from a valid floor tile and marking every reachable neighbor.

func flood_fill(start: Vector2i) -> Dictionary:
    var reachable := {}
    var queue: Array[Vector2i] = [start]

    while queue.size() > 0:
        var pos := queue.pop_front()
        if reachable.has(pos):
            continue
        reachable[pos] = true

        for dir in DIRECTIONS:
            var next := pos + dir
            if is_floor(next) and not reachable.has(next):
                queue.append(next)
    return reachable

After the pass, loop over your floor cells and turn any non-reachable tile back into a wall. This is the cleanup step that makes "looks good" become "actually playable."

Use an enum and match statement to switch algorithms at runtime:

enum MapType { DRUNKARD, CELLULAR, BSP, NOISE }

func generate(map_type: MapType, rng: RandomNumberGenerator) -> void:
    fill_with_walls()
    match map_type:
        MapType.DRUNKARD:
            drunkard_walk(rng, 0.45)
        MapType.CELLULAR:
            cellular_automata(rng, 4)
        MapType.BSP:
            bsp_split(Rect2i(1, 1, width - 2, height - 2), 0, rng)
        MapType.NOISE:
            noise_terrain(rng)

This lets you swap algorithms with a single enum change. Useful for level variety, or for letting players choose a map style.

Build this yourself with the Synthesis tutorial →