Caverna Procedural na Godot com Cellular Automata

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.
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.
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.


