Geração Procedural na Godot: Guia Para Começar

Guia de geração procedural na Godot 4: o que é, por que usar e o panorama dos métodos (ruído, dungeon, cavernas, WFC, labirinto e mundo por chunks).
Geração procedural é quando o jogo monta o mapa por código, em tempo de execução, em vez de você desenhar cada tela à mão. Em vez de pintar um terreno fixo no editor, você escreve um algoritmo que decide onde fica a água, a parede, o corredor e a sala, e cada partida pode sair diferente. Este guia é a porta de entrada para geração procedural na Godot 4: o que é, por que vale a pena e o panorama dos métodos principais, cada um com a sua cara e o seu caso de uso. No fim você tem um exemplo mínimo funcional e os links para os tutoriais específicos de cada técnica.
O que é geração procedural em jogos
A ideia central é trocar conteúdo desenhado por conteúdo calculado. Um algoritmo recebe alguns parâmetros (tamanho do mapa, densidade de paredes, número de salas) e um número de semente, o seed, e devolve um mapa. Mude o seed e você tem outro mapa com as mesmas regras.
Isso não quer dizer bagunça total. Geração procedural boa é aleatoriedade com restrições: o código sorteia dentro de limites que garantem que o resultado continue fazendo sentido como espaço de jogo. Uma caverna ainda precisa ter chão para andar, uma masmorra ainda precisa conectar a entrada à saída. A arte está em escrever regras que produzem variedade sem produzir lixo.
Por que usar geração procedural
Há três motivos práticos que aparecem na maioria dos projetos.
O primeiro é rejogabilidade. Se o mapa muda a cada partida, o jogador não decora o caminho. É o motor dos roguelikes: cada run é uma masmorra nova, e a tensão vem de não saber o que tem atrás da próxima porta. Sem geração procedural, a segunda jogada já seria um passeio pela memória.
O segundo é escala. Desenhar um mundo grande à mão custa muito tempo de equipe. Se você quer um mapa gigante, ou vários mapas, gerar por código é a diferença entre semanas de trabalho manual e um algoritmo que roda em segundos. Jogos de mundo aberto e sobrevivência vivem disso.
O terceiro é mundo infinito. Alguns jogos não têm borda: o mundo se estende enquanto o jogador anda. Isso só é viável se o terreno for calculado sob demanda, pedaço a pedaço, porque guardar um mapa infinito na memória é impossível.
Panorama dos métodos de geração procedural na Godot
Não existe um método único. Cada técnica produz um formato de espaço diferente, e escolher bem é metade do trabalho. Aqui vai o mapa do território.
Ruído (Perlin e Simplex) para terreno
Ruído procedural é uma função matemática que, dado um ponto (x, y), devolve um número que varia de forma suave pelo espaço. Pontos vizinhos retornam valores próximos, o que cria gradientes: baixadas que sobem devagar até virar montanha. Você mapeia faixas desse valor em biomas (água, areia, grama, rocha) e tem um terreno contínuo. Use ruído quando quiser relevo top-down, mapas de altura, distribuição de biomas ou qualquer coisa que precise parecer natural e orgânica. Na Godot 4 o gerador vem pronto na classe FastNoiseLite.
Random walk para dungeon orgânica
Random walk (passeio aleatório) é um cursor que começa num ponto e caminha em direções sorteadas, escavando chão por onde passa. O resultado são túneis sinuosos e cavernosos, sem geometria rígida. É simples de implementar e ótimo para masmorras mais orgânicas ou cavernas estreitas. O cuidado é controlar quanto o cursor anda, senão ele cava demais ou de menos.
Salas e corredores para masmorra clássica
Aqui você sorteia retângulos de sala espalhados pelo mapa, descarta os que se sobrepõem e depois liga as salas com corredores. É o layout clássico de roguelike, com ambientes bem definidos conectados por passagens. Use quando quiser espaços reconhecíveis (uma sala do tesouro, uma sala de chefe) em vez de túneis contínuos. O trabalho fino está em garantir que todas as salas fiquem acessíveis.
Autômato celular para cavernas
Autômato celular parte de um mapa de ruído binário (cada célula é parede ou chão por sorteio) e aplica várias passadas de uma regra simples: uma célula vira parede ou chão conforme quantos vizinhos-parede ela tem. Em poucas iterações a estática vira cavernas orgânicas com contornos suaves. Use para cavernas, grutas e masmorras naturais. O cuidado é que o processo pode deixar bolsões isolados, então vale uma verificação de conectividade no fim.
Wave Function Collapse para padrões coerentes
Wave Function Collapse (WFC) gera mapas a partir de um conjunto de peças com regras de adjacência: cada peça só pode ficar ao lado de certas outras. O algoritmo vai fixando peça por peça, sempre respeitando as regras, até o mapa inteiro ser coerente. É o método para quando você quer que o resultado pareça feito à mão, seguindo um estilo consistente (vilarejos, dungeons com continuidade visual, padrões de tiles que casam). É mais pesado de configurar, mas entrega a maior coerência.
Geração de labirinto (maze)
Algoritmos de labirinto constroem corredores perfeitamente conectados sem ciclos, de forma que existe exatamente um caminho entre quaisquer dois pontos. Técnicas como busca em profundidade com backtracking cavam o labirinto célula a célula. Use quando o próprio desafio é a navegação, ou como esqueleto para depois abrir salas e atalhos. A vantagem é que a conectividade total vem de graça pela natureza do algoritmo.
Mundo infinito por chunks
Para mundos sem borda, você divide o espaço em blocos (chunks) de tamanho fixo e gera cada bloco sob demanda, conforme o jogador se aproxima. Como o ruído é uma função pura das coordenadas, o chunk na posição (x, y) sempre sai igual, então você pode descarregar e recarregar blocos sem guardar o mundo inteiro na memória. Use para jogos de exploração contínua. O cuidado é casar as bordas dos chunks para que o terreno não tenha emendas.
Aprender tudo isso sozinho, no tentativa e erro, costuma travar na parte que os tutoriais soltos não explicam: por que o mapa sai quebrado, como estruturar o código para não virar um nó e como depurar um gerador que só falha em alguns seeds. Se você quer aprender a programar jogos na Godot de verdade, com fundamento e acompanhamento, essa é a diferença entre meses perdidos e um caminho que anda.
Exemplo mínimo: um grid por ruído num TileMapLayer
Para sair do abstrato, aqui vai o menor exemplo que já produz um mapa de verdade: um grid preenchido por ruído e pintado num TileMapLayer da Godot 4. A cena precisa de um nó TileMapLayer com um TileSet configurado que tenha os tiles usados (aqui, um atlas na fonte 0 com coordenadas para água, grama e rocha).
extends TileMapLayer
@export var largura: int = 64
@export var altura: int = 64
@export var seed_mapa: int = 0
const FONTE: int = 0
const TILE_AGUA: Vector2i = Vector2i(0, 0)
const TILE_GRAMA: Vector2i = Vector2i(1, 0)
const TILE_ROCHA: Vector2i = Vector2i(2, 0)
func _ready() -> void:
gerar_mapa()
func gerar_mapa() -> void:
var ruido: FastNoiseLite = FastNoiseLite.new()
ruido.noise_type = FastNoiseLite.TYPE_SIMPLEX
ruido.frequency = 0.03
ruido.seed = seed_mapa
for x: int in range(largura):
for y: int in range(altura):
var valor: float = ruido.get_noise_2d(float(x), float(y))
var tile: Vector2i = escolher_tile(valor)
set_cell(Vector2i(x, y), FONTE, tile)
func escolher_tile(valor: float) -> Vector2i:
if valor < -0.2:
return TILE_AGUA
elif valor < 0.3:
return TILE_GRAMA
else:
return TILE_ROCHA
O que acontece aqui: o FastNoiseLite devolve, para cada célula (x, y), um número aproximadamente entre -1 e 1. A função escolher_tile corta esse intervalo em faixas e devolve as coordenadas de atlas do tile certo. O set_cell pinta a célula no TileMapLayer. A frequency baixa (0.03) é o que faz as regiões saírem grandes e contínuas em vez de virar estática. Troque o seed_mapa e você visita outro mundo com as mesmas regras.
Reprodutibilidade: o seed importa
Repare no campo ruido.seed do exemplo. Ele é a semente do gerador. Com o mesmo seed e o mesmo algoritmo, os valores de ruído saem idênticos, e o mapa inteiro se repete. Isso vale também para RandomNumberGenerator, a classe que você usa quando o método depende de sorteios (random walk, salas, autômato celular):
func novo_rng(semente: int) -> RandomNumberGenerator:
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
rng.seed = semente
return rng
Fixar o seed resolve três problemas de uma vez: você consegue salvar e recriar uma partida, compartilhar um mundo com outro jogador só passando o número, e reproduzir um bug que só aparece num layout específico. Se você usar randomize() sem guardar o seed, perde essa capacidade. A regra prática é: sorteie o seed uma vez, guarde o número, e use um gerador com seed fixo para tudo o que precisa ser reproduzível.
Cuidado central: o mapa precisa ser jogável
O erro mais comum de quem começa é confiar que um mapa aleatório é um mapa jogável. Não é. Autômato celular deixa bolsões de caverna isolados, salas e corredores podem gerar uma sala sem conexão, e um random walk pode nunca alcançar a saída. Um jogador que nasce numa região fechada, ou uma chave que cai numa ilha sem ponte, quebra a partida.
A defesa é sempre a mesma: depois de gerar, verifique a conectividade antes de entregar o mapa ao jogador. O jeito direto é um flood fill a partir da entrada, marcando toda célula de chão alcançável, e depois conferir se a saída e os pontos importantes caíram na região marcada. Se não caíram, abra um caminho ou descarte o mapa e gere outro com um novo seed. Validar alcance não é um extra, é parte do gerador.
Por onde seguir
Este guia é o panorama. Cada método tem sua própria profundidade, e os tutoriais específicos mostram o código completo e os detalhes de API que fazem a técnica funcionar de verdade na Godot 4:
- Terreno procedural com FastNoiseLite para mapas de biomas por ruído.
- Dungeon procedural 2D para salas, corredores e masmorras de roguelike.
- Wave Function Collapse na Godot para mapas coerentes por peças com regras de adjacência.
- Autotile e terreno no TileMap para fazer os tiles se encaixarem automaticamente depois de gerar.
Se você ainda está escolhendo a engine para esse tipo de projeto, vale ver o comparativo Godot vs Unity antes de investir tempo numa delas. Depois disso, a melhor forma de aprender é escolher um método, implementar o exemplo mínimo e ir aprofundando pelos tutoriais acima.
Perguntas frequentes
Preciso saber matemática avançada para fazer geração procedural?
Não para começar. Ruído, random walk e autômato celular usam operações simples: sorteio de números, soma e comparação de vizinhos. A Godot já traz o gerador de ruído pronto na classe FastNoiseLite, então você não implementa Perlin na mão. Matemática mais pesada só aparece quando você quer efeitos específicos, e aí dá para aprender aos poucos.
Qual método devo usar no meu primeiro jogo?
Depende do mapa. Para terreno de mundo aberto top-down, comece por ruído. Para masmorra de roguelike com salas e corredores, comece por salas conectadas ou random walk. Para cavernas orgânicas, autômato celular. Escolha o método pelo formato do espaço que você quer, não pelo que parece mais sofisticado.
O mesmo mapa pode ser gerado de novo depois?
Sim, se você fixar o seed do gerador de números. Com o mesmo seed e o mesmo algoritmo, a sequência de sorteios se repete e o mapa sai idêntico. Isso é útil para salvar partidas, compartilhar mundos entre jogadores e depurar um bug que só acontece em um layout específico.
Como garanto que o jogador não fique preso num mapa gerado?
Nunca confie que um mapa aleatório é jogável. Depois de gerar, rode uma verificação de alcance (um flood fill a partir da entrada) e confira se a saída, os itens e os inimigos estão na mesma região conectada. Se não estiverem, abra um caminho ou descarte o mapa e gere outro com um novo seed.


