Mundo Infinito na Godot 4: Geração Procedural por Chunks

Crie um mundo infinito na Godot 4 com geração procedural por chunks: gere blocos sob demanda ao redor do jogador usando FastNoiseLite e seed global.
Um mundo infinito na Godot parece exigir um mapa gigantesco salvo em disco, mas o truque é o oposto: você não guarda mapa nenhum. A base da geração procedural de mundo infinito é perceber que get_noise_2d(x, y) é uma função pura das coordenadas. Dê o mesmo (x, y) e você recebe sempre o mesmo valor. Isso quer dizer que o mundo já existe implicitamente em cada coordenada possível, e você só precisa calcular o pedaço que o jogador está vendo agora. Neste tutorial você vai montar esse sistema por blocos (chunks) na Godot 4, em GDScript tipado, usando FastNoiseLite e um TileMapLayer.
Por que chunks resolvem o problema do mundo infinito
Imagine tentar gerar e guardar um mapa de um milhão por um milhão de tiles. É inviável: não cabe na memória, demora uma eternidade para gerar e a maior parte nunca aparece na tela. O jogador enxerga só um retângulo ao redor dele.
A ideia de chunk resolve isso dividindo o mundo numa grade de blocos. Cada chunk é um quadrado de, digamos, 16 por 16 tiles. Em vez de pensar em tiles soltos, você pensa em blocos. A regra fica simples: mantenha carregados apenas os chunks num raio ao redor do jogador e descarregue os que ficaram para trás.
O detalhe que faz tudo funcionar é a reprodutibilidade do ruído. Como get_noise_2d depende só das coordenadas e do seed, um chunk que você descarregou e depois regerou sai exatamente igual. O jogador anda para a direita, os chunks da esquerda somem da memória, ele volta, e os mesmos chunks reaparecem idênticos. Você nunca precisou guardá-los. Se este é seu primeiro contato com ruído, vale ler antes o pilar de geração procedural e o passo a passo de terreno procedural com FastNoiseLite, porque aqui eu assumo que você já sabe ler um valor de ruído.
A montagem da cena
A cena é enxuta. Você precisa de um nó raiz com o script do gerador, um TileMapLayer filho onde os tiles vão ser pintados, e uma referência ao jogador (um CharacterBody2D, por exemplo) para saber onde ele está.
No TileMapLayer, configure um TileSet com os tiles do mundo. Anote os atlas_coords de cada tile que você vai usar (água, grama, montanha). O source_id normalmente é 0 se você tem uma única fonte de atlas no TileSet.
Definindo o tamanho do chunk e o raio de carga
Comece pelas constantes. Elas governam todo o comportamento do sistema.
extends Node2D
const TAMANHO_CHUNK: int = 16
const RAIO_CARGA: int = 2
const SOURCE_ID: int = 0
@onready var mapa: TileMapLayer = $TileMapLayer
@onready var jogador: CharacterBody2D = $Jogador
var ruido: FastNoiseLite = FastNoiseLite.new()
var chunks_carregados: Dictionary = {}
var chunk_atual: Vector2i = Vector2i(99999, 99999)
TAMANHO_CHUNK é quantos tiles cabem em cada lado de um chunk. RAIO_CARGA de 2 significa manter uma grade de 5 por 5 chunks ao redor do jogador (dois para cada lado mais o do meio). O Dictionary chunks_carregados é o coração do rastreamento: a chave é a posição do chunk na grade (um Vector2i), e é ele que impede recriar um chunk que já existe. O chunk_atual guarda em qual chunk o jogador estava na última checagem, começando num valor absurdo de propósito para forçar a primeira geração.
Preparando o ruído com seed global
O FastNoiseLite é configurado uma vez, no _ready. O seed é o que torna o mundo reproduzível: fixe-o e o mundo inteiro fica determinístico.
func _ready() -> void:
ruido.noise_type = FastNoiseLite.TYPE_SIMPLEX_SMOOTH
ruido.seed = 1337
ruido.frequency = 0.03
_atualizar_chunks()
Deixei o seed fixo em 1337 para você testar com um mundo estável, mas na prática você sorteia um número no início da partida e o salva. Guardado o seed, você recria o mesmo mundo quando quiser. A frequency baixa, perto de 0.03, gera massas grandes e contínuas de terreno em vez de estática pixel a pixel.
Descobrindo em qual chunk o jogador está
Toda a lógica gira em torno de uma conta: converter a posição do jogador na posição do chunk. Primeiro a posição global vira coordenada de tile, usando local_to_map do próprio TileMapLayer. Depois a coordenada de tile vira coordenada de chunk, dividindo pelo tamanho do chunk com floori para arredondar para baixo, inclusive em coordenadas negativas.
func _chunk_do_jogador() -> Vector2i:
var pos_local: Vector2 = mapa.to_local(jogador.global_position)
var tile: Vector2i = mapa.local_to_map(pos_local)
return Vector2i(
floori(float(tile.x) / TAMANHO_CHUNK),
floori(float(tile.y) / TAMANHO_CHUNK)
)
O floori é essencial. Uma divisão inteira comum arredonda em direção ao zero, o que quebra a grade do lado negativo do mundo: o tile -1 cairia no chunk 0 em vez do chunk -1, criando uma costura visível na origem. Com floori sobre o float, a grade fica contínua em todas as direções, que é exatamente o que um mundo infinito precisa.
Se você quer entender por que a Godot é uma escolha tão boa para esse tipo de projeto 2D frente a outras engines, dá uma olhada no comparativo Godot vs Unity.
O loop de carga e descarga
Agora o método central. Ele só faz trabalho quando o jogador muda de chunk, para não processar a mesma coisa a cada quadro.
func _process(_delta: float) -> void:
var chunk: Vector2i = _chunk_do_jogador()
if chunk != chunk_atual:
chunk_atual = chunk
_atualizar_chunks()
func _atualizar_chunks() -> void:
var necessarios: Dictionary = {}
for cx in range(chunk_atual.x - RAIO_CARGA, chunk_atual.x + RAIO_CARGA + 1):
for cy in range(chunk_atual.y - RAIO_CARGA, chunk_atual.y + RAIO_CARGA + 1):
var pos_chunk: Vector2i = Vector2i(cx, cy)
necessarios[pos_chunk] = true
if not chunks_carregados.has(pos_chunk):
_gerar_chunk(pos_chunk)
chunks_carregados[pos_chunk] = true
for pos_chunk: Vector2i in chunks_carregados.keys():
if not necessarios.has(pos_chunk):
_descarregar_chunk(pos_chunk)
chunks_carregados.erase(pos_chunk)
A lógica tem duas fases. Na primeira, varro a grade de chunks dentro do raio e marco cada um como necessário. Se um chunk necessário ainda não está no Dictionary, eu gero e registro. O has é o guarda que evita o retrabalho: chunk que já existe é pulado, nada é regerado à toa. Na segunda fase, percorro os chunks carregados e descarrego qualquer um que não esteja mais na lista de necessários, apagando a entrada do Dictionary. Assim o conjunto carregado acompanha o jogador como uma janela que desliza pelo mapa.
Se seu mundo trava por um instante quando muitos chunks surgem de uma vez, esse é o momento certo de pensar em quem está programando o jogo: aprender a dividir a geração em quadros, usar threads e entender o custo real de cada chamada é o que separa um protótipo de um jogo que roda liso. Esse é o tipo de fundamento que a gente destrincha no curso de Godot do CursoGame.Dev, aprendendo a programar de verdade, no seu ritmo, sem "assinatura" e sem "call" de vendas.
Gerando um chunk tile a tile
Gerar o chunk é o lugar onde o ruído vira mundo. Para cada tile dentro do bloco, calculo a coordenada global do tile, leio o ruído naquele ponto e escolho qual tile do atlas pintar conforme a faixa do valor.
func _gerar_chunk(pos_chunk: Vector2i) -> void:
var base_x: int = pos_chunk.x * TAMANHO_CHUNK
var base_y: int = pos_chunk.y * TAMANHO_CHUNK
for x in range(TAMANHO_CHUNK):
for y in range(TAMANHO_CHUNK):
var tile_x: int = base_x + x
var tile_y: int = base_y + y
var valor: float = ruido.get_noise_2d(tile_x, tile_y)
var atlas: Vector2i = _atlas_para_altura(valor)
mapa.set_cell(Vector2i(tile_x, tile_y), SOURCE_ID, atlas)
func _atlas_para_altura(valor: float) -> Vector2i:
if valor < -0.2:
return Vector2i(0, 0) # agua
elif valor < 0.2:
return Vector2i(1, 0) # grama
else:
return Vector2i(2, 0) # montanha
Repare que eu uso as coordenadas globais do tile (tile_x, tile_y) na chamada do ruído, não as coordenadas locais dentro do chunk. É isso que garante que os chunks se encaixem sem costura: o ruído é contínuo pelo mundo todo, então a borda de um chunk combina naturalmente com a borda do vizinho. Ajuste os atlas_coords no _atlas_para_altura para os tiles reais do seu TileSet.
Descarregando o chunk
Descarregar é o espelho de gerar. Em vez de pintar, você apaga as células daquele bloco com erase_cell.
func _descarregar_chunk(pos_chunk: Vector2i) -> void:
var base_x: int = pos_chunk.x * TAMANHO_CHUNK
var base_y: int = pos_chunk.y * TAMANHO_CHUNK
for x in range(TAMANHO_CHUNK):
for y in range(TAMANHO_CHUNK):
mapa.erase_cell(Vector2i(base_x + x, base_y + y))
Apagar as células libera a memória do TileMapLayer e mantém a cena leve, por mais longe que o jogador caminhe. E como a geração é determinística, não há perda: quando o jogador voltar, _gerar_chunk reconstrói o bloco idêntico a partir do ruído.
O que você tem nas mãos agora
Com essas poucas peças você já tem um mundo que se estende sem fim em todas as direções, inclusive para coordenadas negativas, consumindo memória constante. O Dictionary rastreia o que está carregado, o has evita o retrabalho, o floori mantém a grade contínua e o seed torna tudo reproduzível. Esse é o esqueleto por trás de jogos estilo mundo aberto e sandbox 2D: um Terraria ou um Starbound nascem dessa mesma ideia de blocos gerados sob demanda.
Daqui dá para crescer em várias direções. Um Dictionary separado de tiles modificados pelo jogador reaplicado após _gerar_chunk dá persistência de construções e escavações. Vários TileMapLayer em camadas permitem minério, vegetação e decoração sobre o terreno base. E mover a geração pesada para um thread evita o engasgo quando muitos chunks surgem juntos. Mas a fundação é essa, e ela é pequena de propósito: mundo infinito não é guardar tudo, é saber recalcular o pedaço certo na hora certa.
Perguntas frequentes
Como um mundo infinito cabe na memória?
Ele não cabe inteiro, e esse é o ponto. Você guarda apenas os chunks perto do jogador em um Dictionary e descarrega os distantes. Como get_noise_2d é função pura das coordenadas, qualquer bloco pode ser regerado idêntico quando o jogador voltar, sem precisar estocar o mapa todo.
Qual o tamanho ideal de chunk na Godot?
Depende do seu jogo, mas 16 ou 32 tiles por lado é um ponto de partida seguro para 2D top-down. Chunk pequeno descarrega rápido e gasta menos por bloco, mas atualiza com mais frequência. Chunk grande reduz a frequência de atualização e aumenta o custo de cada geração. Meça e ajuste.
O mundo é reproduzível entre sessões?
Sim, desde que você fixe o mesmo noise.seed. Com o seed salvo, cada coordenada retorna sempre o mesmo valor de ruído, então o mundo é idêntico toda vez que você carregar aquele seed. Guarde o número do seed para recriar o mesmo mundo depois.
Preciso salvar as alterações do jogador no mundo?
A geração em si não precisa de save, pois é recalculada pelo ruído. Mas mudanças feitas pelo jogador (blocos quebrados, construções) não vêm do ruído, então essas sim você guarda à parte, geralmente num Dictionary de tiles modificados por coordenada, e reaplica depois de gerar o chunk.


