procgen-patterns

Procgen Patterns

FastNoiseLite Terrain Generation

# Layered noise terrain heightmap - Godot 4
class_name TerrainGenerator extends Node
@export var width: int = 128
@export var height: int = 128
@export var seed: int = 0

@export var base_frequency: float = 0.01
@export var octaves: int = 5
@export var lacunarity: float = 2.0  # Frequency multiplier per octave
@export var gain: float = 0.5        # Amplitude multiplier per octave

func generate_heightmap() -> Image:
    var noise := FastNoiseLite.new()
    noise.noise_type = FastNoiseLite.TYPE_SIMPLEX
    noise.fractal_type = FastNoiseLite.FRACTAL_FBM
    noise.seed = seed
    noise.frequency = base_frequency
    noise.fractal_octaves = octaves
    noise.fractal_lacunarity = lacunarity
    noise.fractal_gain = gain

    var img := Image.create(width, height, false, Image.FORMAT_R8)
    for y in height:
        for x in width:
            var value := (noise.get_noise_2d(x, y) + 1.0) * 0.5  # Normalize to [0,1]
            img.set_pixel(x, y, Color(value, 0, 0))
    return img

func sample_height(world_pos: Vector2) -> float:
    # Used at runtime for placing objects at correct heights
    var noise := FastNoiseLite.new()
    noise.seed = seed
    noise.frequency = base_frequency
    return (noise.get_noise_2d(world_pos.x, world_pos.y) + 1.0) * 0.5

BSP Dungeon Generator

# Binary Space Partitioning dungeon - produces structured room layouts
class_name BSPDungeon extends RefCounted

class BSPNode:
    var rect: Rect2i
    var left: BSPNode
    var right: BSPNode
    var room: Rect2i  # Only set on leaf nodes

    func _init(r: Rect2i) -> void:
        rect = r

const MIN_LEAF_SIZE := 10
const MIN_ROOM_SIZE := 4

var _rng: RandomNumberGenerator
var _rooms: Array[Rect2i] = []
var _corridors: Array[Array] = []  # Array of [Vector2i, Vector2i] pairs

func generate(bounds: Rect2i, seed: int) -> void:
    _rng = RandomNumberGenerator.new()
    _rng.seed = seed
    _rooms.clear()
    _corridors.clear()

    var root := BSPNode.new(bounds)
    _split(root, 0)
    _create_rooms(root)
    _connect_rooms(root)

func _split(node: BSPNode, depth: int) -> void:
    if depth > 5:
        return
    var split_horizontal := _rng.randi() % 2 == 0
    var min_size := MIN_LEAF_SIZE * 2
    if node.rect.size.x < min_size and node.rect.size.y < min_size:
        return  # Too small to split

    if node.rect.size.x > node.rect.size.y:
        split_horizontal = false  # Force vertical split for wide nodes

    var split_pos: int
    if split_horizontal:
        split_pos = _rng.randi_range(MIN_LEAF_SIZE, node.rect.size.y - MIN_LEAF_SIZE)
        node.left = BSPNode.new(Rect2i(node.rect.position, Vector2i(node.rect.size.x, split_pos)))
        node.right = BSPNode.new(Rect2i(
            node.rect.position + Vector2i(0, split_pos),
            Vector2i(node.rect.size.x, node.rect.size.y - split_pos)
        ))
    else:
        split_pos = _rng.randi_range(MIN_LEAF_SIZE, node.rect.size.x - MIN_LEAF_SIZE)
        node.left = BSPNode.new(Rect2i(node.rect.position, Vector2i(split_pos, node.rect.size.y)))
        node.right = BSPNode.new(Rect2i(
            node.rect.position + Vector2i(split_pos, 0),
            Vector2i(node.rect.size.x - split_pos, node.rect.size.y)
        ))

    _split(node.left, depth + 1)
    _split(node.right, depth + 1)

func _create_rooms(node: BSPNode) -> void:
    if node.left == null and node.right == null:
        # Leaf: create a room with padding
        var padding := 1
        var max_w := node.rect.size.x - padding * 2
        var max_h := node.rect.size.y - padding * 2
        if max_w < MIN_ROOM_SIZE or max_h < MIN_ROOM_SIZE:
            return
        var w := _rng.randi_range(MIN_ROOM_SIZE, max_w)
        var h := _rng.randi_range(MIN_ROOM_SIZE, max_h)
        var x := node.rect.position.x + padding + _rng.randi_range(0, max_w - w)
        var y := node.rect.position.y + padding + _rng.randi_range(0, max_h - h)
        node.room = Rect2i(x, y, w, h)
        _rooms.append(node.room)
        return
    if node.left:
        _create_rooms(node.left)
    if node.right:
        _create_rooms(node.right)

func _connect_rooms(node: BSPNode) -> void:
    if node.left == null or node.right == null:
        return
    var left_room := _get_room(node.left)
    var right_room := _get_room(node.right)
    if left_room != Rect2i() and right_room != Rect2i():
        var start := left_room.get_center()
        var end := right_room.get_center()
        _corridors.append([start, end])  # L-shaped corridor between centers
    _connect_rooms(node.left)
    _connect_rooms(node.right)

func _get_room(node: BSPNode) -> Rect2i:
    if node.room != Rect2i():
        return node.room
    var left_room := Rect2i()
    var right_room := Rect2i()
    if node.left:
        left_room = _get_room(node.left)
    if node.right:
        right_room = _get_room(node.right)
    if left_room == Rect2i():
        return right_room
    return left_room

func get_rooms() -> Array[Rect2i]:
    return _rooms