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)

The drunkard's walk (also called a random walk) is the simplest procedural generation algorithm that produces interesting results. A single walker starts at the center of the grid and picks a random cardinal direction each step -- up, down, left, or right. Wherever it steps, it carves a floor tile. Because the walker frequently backtracks over its own path, you get branching passages, irregular chambers, and dead ends rather than a single long corridor. The winding, unpredictable path is what makes the caves feel organic.

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.

Tuning the drunkard's walk: The target_coverage parameter controls cave density. 0.35-0.40 produces tight, winding caves with lots of walls. 0.50+ opens the map up into wider chambers. The walker revisits already-carved tiles often at higher coverage targets -- that's expected and is what creates the branching pattern. Boundary clamping with Vector2i.clamp() keeps the walker one tile away from map edges, leaving a solid border.

Build this yourself with the Drunkard's Walk tutorial →

Cellular automata map generation works in two phases. First, scatter random noise across the grid -- each cell has roughly a 45% chance of being a wall. Then repeatedly apply the 4-5 rule: count each cell's 8 neighbors (the Moore neighborhood), and if 5 or more are walls, make it a wall too. Walls next to walls survive; isolated walls get eaten. After 4-5 passes, random static sharpens into smooth, wide-open cave chambers connected by natural-looking passages. The result is very different from a drunkard's walk -- cellular automata caves have rounder, more open rooms instead of winding corridors.

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: double-buffering. You must read from a snapshot and write to the live grid. If you read and write the same grid in-place, changing one cell alters the neighbor count of the next cell in the same pass. The snapshot (created with duplicate(true) for a deep copy) freezes the state so all cells read from the same generation. This is the most common bug in cellular automata implementations.

Tuning: The initial wall probability (0.45) controls the final cave shape. Lower values (0.35-0.40) produce more open space with thin walls. Higher values (0.50-0.55) produce narrow tunnels through thick rock. Four iterations is a good default; more over-smooths the map into a single blob.

Warning: Cellular automata can produce disconnected chambers because each cell is processed independently. Always run flood fill afterward to keep only the largest connected region.

Build this yourself with the Cellular Automata tutorial →

Binary Space Partitioning (BSP) produces the classic roguelike layout: rectangular rooms connected by corridors, with no overlap and guaranteed connectivity. The algorithm works by recursively splitting the map rectangle into two halves -- sometimes horizontally, sometimes vertically -- until every partition is too small to split further. These terminal partitions are the "leaves" of a binary tree. Each leaf gets a room placed inside it with random size and position. Then you walk back up the tree and connect each pair of sibling rooms with an L-shaped corridor. The tree structure means every room connects to its sibling, which connects to its sibling, all the way back to the root.

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.

Tuning BSP dungeons: MIN_PARTITION controls the density of rooms. Smaller values (6-8) create more, smaller rooms packed tightly together. Larger values (12-15) create fewer, bigger rooms with longer corridors between them. The split axis is chosen based on which dimension is longer, keeping partitions roughly square. Random split positions within the valid range (MIN_PARTITION to size - MIN_PARTITION) prevent degenerate slivers.

Build this yourself with the BSP Dungeons tutorial →

Noise-based terrain generation uses Godot's built-in FastNoiseLite to produce smooth, continuous value fields across the grid -- imagine a topographic map where neighboring cells have similar heights. You sample the noise at each grid position, getting a value between -1.0 and 1.0. Values above a threshold become land (floor tiles), values below become water (wall tiles). The raw output looks like random continents, so you shape it by applying distance falloff from the center -- cells near the edges get their values pushed down, turning the map into an island. Fractal octaves layer multiple noise samples at different scales to add coastline detail: octave 1 draws the broad landmass shape, octaves 2-4 add smaller bumps and inlets.

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 can leave disconnected pockets of floor tiles that the player can never reach. This happens because both algorithms process each cell independently -- they don't track connectivity while generating. Flood fill solves the problem after generation. Starting from the player's spawn position, it visits every reachable floor tile using a queue-based breadth-first search.

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 flood fill completes, loop over all floor cells in the grid. Any floor tile NOT in the reachable dictionary is a disconnected island -- fill it back with walls. This cleanup step is what turns "looks good" into "actually playable." Drunkard's walk and BSP don't need this step because their generation methods guarantee connectivity by construction.

When to run flood fill: Always after cellular automata or noise terrain. Never needed after drunkard's walk (the walker is always connected) or BSP (the tree structure connects everything). If you combine algorithms -- for example, cellular automata for caves with BSP corridors connecting them -- run flood fill on the final result to be safe.

Each algorithm produces a different type of map. The right choice depends on what kind of game space you need.

Drunkard's walk is the fastest to implement (under 15 lines) and produces cave systems that work for early prototypes. The tradeoff is low control -- you can't predict the shape of any individual map, only the density.

Cellular automata produces the most visually distinct caves: round, smooth chambers connected by natural passages. The 4-5 rule is easy to tweak (try 4-4 or 5-5 for different shapes), but you always need flood fill afterward.

BSP gives you the most control. Adjusting MIN_PARTITION, room padding, and corridor style lets you create everything from cramped catacombs to spacious hall-and-corridor layouts. This is what most people think of as a "roguelike dungeon."

Noise terrain is the outlier -- it produces geographic landscapes rather than architectural dungeons. Combine it with distance falloff for island maps, or use different threshold bands for multiple biome types (deep water, shallow water, sand, grass, mountain).

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 is the strategy pattern -- all four generators share the same interface (fill the grid, then carve), so swapping them is a one-line enum change. Useful for varying dungeon types across floors, or for letting players choose a map style.

Build the strategy pattern yourself with the Synthesis tutorial →