Voltar para o Blog
Quest Log

Caverna Procedural na Godot com Cellular Automata

Caverna 2D gerada por computador com paredes orgânicas e túneis conectados

Aprenda geração procedural de caverna na Godot 4 com cellular automata: grid aleatório, regra dos vizinhos, TileMapLayer e flood fill passo a passo.

Ferramenta:Godot

Gerar um mapa de caverna à mão é trabalhoso e repetitivo. A geração procedural de caverna resolve isso: você escreve uma regra simples, roda algumas iterações e o computador devolve um mapa novo e orgânico a cada partida. Neste tutorial você vai montar esse sistema na Godot 4 usando cellular automata (autômato celular), do grid aleatório inicial até a caverna conectada e pintada num TileMapLayer, tudo em GDScript tipado.

O resultado é aquele formato de caverna irregular, com paredes tortas e salões abertos, bem diferente de uma dungeon de salas retangulares. E o melhor: o algoritmo cabe em uma tela de código.

Por que cellular automata gera cavernas orgânicas

Antes de escrever qualquer linha, vale entender a escolha. Um autômato celular trabalha sobre um grid onde cada célula olha para os vizinhos e decide o próprio estado a partir de uma regra. Quando você começa com ruído aleatório (parede ou chão jogados ao acaso) e aplica a regra "vire parede se a maioria dos seus vizinhos for parede", o ruído se agrupa. Blocos de parede se fundem, buracos soltos somem e o que sobra são massas conectadas com bordas irregulares. Isso é exatamente a cara de uma caverna natural.

Compare com outras abordagens de geração procedural. Random walk cava um túnel passo a passo e tende a produzir corredores sinuosos. Colocação de salas com conexão por corredores dá aquele layout clássico de dungeon, estruturado e retangular. Cellular automata não planeja nada: ele apenas suaviza o caos até virar algo orgânico. Por isso é a ferramenta certa quando você quer cavernas, grutas e áreas naturais, e não masmorras arquitetadas.

Se você quer comparar essa técnica com a geração de masmorras estruturadas, vale ler depois o tutorial de dungeon procedural na Godot e o pilar de geração procedural de mapas, que amarra todas as abordagens.

Passo 1: preencher o grid aleatoriamente

Tudo começa com uma matriz de inteiros. Cada posição guarda 1 para parede ou 0 para chão. Vamos sortear o estado inicial de cada célula com uma probabilidade fixa de parede. Um bom ponto de partida é algo em torno de 45% de paredes: menos que isso e a caverna vira um salão vazio, mais que isso e ela entope.

extends Node2D

const WIDTH: int = 80
const HEIGHT: int = 45
const FILL_PROBABILITY: float = 0.45

const WALL: int = 1
const FLOOR: int = 0

var grid: Array = []
var rng: RandomNumberGenerator = RandomNumberGenerator.new()

func _ready() -> void:
    rng.randomize()
    grid = _generate_noise_grid()

func _generate_noise_grid() -> Array:
    var new_grid: Array = []
    for y: int in range(HEIGHT):
        var row: Array = []
        for x: int in range(WIDTH):
            # bordas sempre parede para fechar o mapa
            if x == 0 or y == 0 or x == WIDTH - 1 or y == HEIGHT - 1:
                row.append(WALL)
            elif rng.randf() < FILL_PROBABILITY:
                row.append(WALL)
            else:
                row.append(FLOOR)
        new_grid.append(row)
    return new_grid

Duas decisões importantes aqui. Primeira: as bordas do mapa sempre nascem como parede, assim a caverna nunca fica aberta para o vazio. Segunda: usamos RandomNumberGenerator em vez de randi() global, porque isso deixa a porta aberta para fixar uma seed depois e reproduzir o mesmo mapa (ótimo para depurar e para daily runs).

Passo 2: rodar a regra dos vizinhos

Aqui mora o autômato. Para cada célula, contamos quantas das oito vizinhas são parede. Se forem cinco ou mais, a célula vira parede; senão, vira chão. Essa é a famosa regra 4-5 (4 vizinhos para nascer, 5 para sobreviver, na prática virando um limiar único de 5).

O detalhe que todo mundo erra: você não pode editar o grid enquanto conta. Se você alterar uma célula e a vizinha seguinte contar o novo valor, a simulação contamina a si mesma. A regra precisa ler o estado antigo inteiro e escrever num grid novo.

const ITERATIONS: int = 5
const WALL_THRESHOLD: int = 5

func _count_wall_neighbors(source: Array, cx: int, cy: int) -> int:
    var count: int = 0
    for dy: int in range(-1, 2):
        for dx: int in range(-1, 2):
            if dx == 0 and dy == 0:
                continue
            var nx: int = cx + dx
            var ny: int = cy + dy
            # fora do mapa conta como parede
            if nx < 0 or ny < 0 or nx >= WIDTH or ny >= HEIGHT:
                count += 1
            elif source[ny][nx] == WALL:
                count += 1
    return count

func _step_automaton(source: Array) -> Array:
    var next_grid: Array = []
    for y: int in range(HEIGHT):
        var row: Array = []
        for x: int in range(WIDTH):
            var walls: int = _count_wall_neighbors(source, x, y)
            if walls >= WALL_THRESHOLD:
                row.append(WALL)
            else:
                row.append(FLOOR)
        next_grid.append(row)
    return next_grid

func _smooth_grid() -> void:
    for i: int in range(ITERATIONS):
        grid = _step_automaton(grid)

Tratar o fora do mapa como parede reforça as bordas a cada passo, o que ajuda a caverna a se fechar nas pontas. Chame _smooth_grid() logo depois de gerar o ruído, dentro do _ready(). Cada iteração torna o mapa mais suave. Com 5 passos você já tem paredes coesas sem perder os detalhes internos.

Aprender sozinho essa parte costuma travar justamente aqui: o código roda, mas o mapa sai estranho e você não sabe se o problema é a probabilidade inicial, o número de iterações ou um off-by-one na contagem de vizinhos. Depurar lógica de grid sem alguém apontando o erro vira horas de tentativa e erro. Programar de verdade na Godot, entendendo cada decisão em vez de copiar trechos soltos, é o que separa quem trava de quem termina o projeto.

Curso de Godot
Quer fazer seu primeiro jogo na Godot?

No curso de Godot da CursoGame.Dev você vai do zero ao primeiro jogo, com um desafio prático em cada level e suporte individual no WhatsApp quando travar.

Conhecer o curso de Godot
Suporte no WhatsAppAcesso vitalícioGarantia de 7 dias

Passo 3: pintar o resultado num TileMapLayer

Com o grid pronto, falta desenhar. Na Godot 4 o nó é o TileMapLayer, e cada célula é posicionada com set_cell, que recebe um Vector2i de coordenada, o id do source do tileset e o atlas_coords do tile dentro do atlas.

Monte a cena com um nó TileMapLayer filho, configure um TileSet com pelo menos dois tiles (um de parede, um de chão) e anote as coordenadas de atlas de cada um. No exemplo abaixo, o chão está em (0, 0) e a parede em (1, 0) do source 0.

@onready var tile_map_layer: TileMapLayer = $TileMapLayer

const SOURCE_ID: int = 0
const FLOOR_ATLAS: Vector2i = Vector2i(0, 0)
const WALL_ATLAS: Vector2i = Vector2i(1, 0)

func _paint_grid() -> void:
    tile_map_layer.clear()
    for y: int in range(HEIGHT):
        for x: int in range(WIDTH):
            var cell: Vector2i = Vector2i(x, y)
            if grid[y][x] == WALL:
                tile_map_layer.set_cell(cell, SOURCE_ID, WALL_ATLAS)
            else:
                tile_map_layer.set_cell(cell, SOURCE_ID, FLOOR_ATLAS)

Chame _paint_grid() por último, depois de suavizar e (no próximo passo) garantir a conectividade. O clear() no começo evita tiles fantasma quando você regenera o mapa em tempo de execução.

Passo 4: garantir conectividade com flood fill

Cellular automata quase sempre deixa bolsões de chão separados do resto: pequenas bolhas sem ligação com a área principal. Se o jogador nasce num bolsão fechado, o mapa é injogável. A solução é um flood fill que encontra cada região de chão e decide o que fazer com ela.

A estratégia mais simples e robusta: percorra o grid, faça flood fill a partir de cada célula de chão ainda não visitada, guarde cada região como uma lista de coordenadas e, no fim, mantenha só a maior região. Todo chão que não pertence a ela vira parede. Assim você garante uma caverna 100% atravessável.

func _get_region(start: Vector2i, visited: Dictionary) -> Array:
    var region: Array = []
    var queue: Array = [start]
    visited[start] = true
    while not queue.is_empty():
        var current: Vector2i = queue.pop_back()
        region.append(current)
        var neighbors: Array = [
            Vector2i(current.x + 1, current.y),
            Vector2i(current.x - 1, current.y),
            Vector2i(current.x, current.y + 1),
            Vector2i(current.x, current.y - 1),
        ]
        for n: Vector2i in neighbors:
            if n.x < 0 or n.y < 0 or n.x >= WIDTH or n.y >= HEIGHT:
                continue
            if visited.has(n):
                continue
            if grid[n.y][n.x] != FLOOR:
                continue
            visited[n] = true
            queue.append(n)
    return region

func _keep_largest_region() -> void:
    var visited: Dictionary = {}
    var largest: Array = []
    for y: int in range(HEIGHT):
        for x: int in range(WIDTH):
            var cell: Vector2i = Vector2i(x, y)
            if grid[y][x] == FLOOR and not visited.has(cell):
                var region: Array = _get_region(cell, visited)
                if region.size() > largest.size():
                    largest = region
    # transforma todo chão em parede, depois reabre só a maior região
    for y: int in range(HEIGHT):
        for x: int in range(WIDTH):
            grid[y][x] = WALL
    for cell: Vector2i in largest:
        grid[cell.y][cell.x] = FLOOR

O flood fill aqui usa busca em largura com uma fila simples e um dicionário de visitados, varrendo só vizinhos ortogonais (cima, baixo, esquerda, direita). Depois de rodar, o grid tem uma única região de chão conectada. Se em vez de descartar os bolsões você quisesse conectá-los, bastaria cavar um túnel reto entre o centro de cada região e a maior, mas descartar é mais simples e dá ótimo resultado para a maioria dos jogos.

Com os quatro passos na ordem certa, o _ready() final fica assim:

func _ready() -> void:
    rng.randomize()
    grid = _generate_noise_grid()
    _smooth_grid()
    _keep_largest_region()
    _paint_grid()

Ajustando os parâmetros

Agora é brincar com os números. A probabilidade de preenchimento controla a densidade: valores perto de 0.40 abrem salões amplos, perto de 0.50 criam labirintos apertados. O número de iterações controla a suavidade: 4 a 6 é a faixa saudável. E o limiar de 5 vizinhos é o coração da regra; abaixar para 4 engorda as paredes, subir para 6 afina tudo até quase sumir.

Fixe uma seed com rng.seed = 12345 no lugar de rng.randomize() enquanto estiver testando. Assim você compara o efeito de cada parâmetro sobre o mesmo mapa base, em vez de perseguir um alvo que muda a cada execução. Quando o resultado agradar, volte ao randomize() para variedade em produção.

Para onde levar daqui

Você tem uma caverna procedural funcional e conectada. Os próximos passos naturais são semear inimigos e itens nas células de chão da maior região, adicionar colisão nas paredes com um tile de física no TileSet, e combinar essa caverna orgânica com salas estruturadas para mapas híbridos. Se quiser decidir em qual motor investir essa jornada, o comparativo Godot vs Unity ajuda a pesar os prós de cada um para projetos 2D procedurais.

O ponto central é que cellular automata entrega muito com pouco código. Uma regra de vizinhança, algumas iterações e um flood fill transformam ruído puro em um mapa jogável. A partir dessa base, cada ajuste de parâmetro abre um estilo diferente de caverna, e tudo isso roda nativamente na Godot 4.

Perguntas frequentes

Quantas iterações de cellular automata são ideais para uma caverna?

Entre 4 e 6 iterações costuma dar o melhor equilíbrio. Poucas iterações deixam ruído solto; muitas apagam detalhes e fecham passagens. Teste com a mesma seed e ajuste.

Qual a diferença entre cellular automata e random walk para gerar mapas?

Cellular automata suaviza um grid aleatório pela regra dos vizinhos e produz cavernas orgânicas com paredes irregulares. Random walk cava um caminho e gera corredores e salas mais estruturados, tipo dungeon.

Por que preciso de flood fill na geração procedural de caverna?

O autômato celular costuma deixar bolsões de chão isolados, sem conexão com a área principal. O flood fill identifica cada região e permite remover as pequenas ou conectar tudo, garantindo que o jogador consiga atravessar o mapa.

Dá para usar esse código na Godot 3?

A lógica do autômato é idêntica, mas a API muda. A Godot 4 usa TileMapLayer e set_cell com Vector2i; na Godot 3 você usaria o nó TileMap antigo com set_cell por coordenadas separadas.