Como Fazer um Roguelike: Rejogabilidade com Pouco Conteúdo

Se você está sozinho ou num time pequeno e quer um jogo que rende muitas horas sem precisar desenhar cem fases à mão, aprender como fazer um roguelike é uma das melhores apostas que existem. A lógica do gênero é direta: em vez de você construir todo o conteúdo manualmente, o jogo monta as partidas na hora, combinando peças que você criou. Um punhado de salas, inimigos e itens bem feitos vira centenas de partidas diferentes. É escopo de arte pequeno gerando rejogabilidade grande, e é por isso que o gênero é tão querido por quem faz jogo indie. Brotato e Halls of Torment, dois sucessos feitos em Godot, são exatamente desse estilo.

Este texto é o mapa do gênero pra iniciante. A ideia não é entregar um roguelike pronto dentro de um post, e sim te mostrar quais são as peças, por que o gênero encaixa tão bem no trabalho solo e em que ordem montar tudo sem se afogar. Quando esse mapa fica claro, qualquer tutorial passa a fazer sentido, porque você para de copiar passos e começa a enxergar o sistema por trás.

O que define um roguelike (e o que é roguelite)

Três coisas formam o coração do gênero. A primeira é a morte permanente, o permadeath: quando o personagem morre, a partida acaba e você recomeça, não tem salvar e voltar de onde parou. A segunda é a geração procedural: o mapa, os inimigos e os itens mudam a cada partida, então nunca é a mesma corrida duas vezes. A terceira é a estrutura de runs, ou partidas: cada partida é uma tentativa fechada, com começo, meio e fim, e o jogo é feito pra você jogar muitas delas. Junte isso a uma progressão que evolui entre as partidas e você tem a fórmula.

A diferença entre roguelike e roguelite, sem academicismo, é só o quanto fica de uma partida pra outra. No roguelike purista, morreu, perdeu tudo, volta totalmente ao zero. No roguelite, você morre e recomeça do mesmo jeito, mas guarda algum progresso permanente, como upgrades, moedas ou personagens novos desbloqueados. Essa progressão que fica entre partidas é a meta progressão, e ela dá um senso de avanço mesmo quando você perde. A maioria dos sucessos modernos é roguelite, e pra quem está começando esse é o caminho mais agradável de fazer e de jogar.

Por que o roguelike é tão bom pro indie

Aqui está o motivo de o gênero ser quase um cheat code pra quem trabalha sozinho. Num jogo linear, cada hora de gameplay costuma exigir horas de fase desenhada à mão, arte específica, level design cuidado, tudo manual. Num roguelike, o conteúdo é gerado por sistema. Você cria as peças uma vez, e o jogo as recombina infinitamente. O custo de arte e de level design não cresce na mesma proporção que o tempo de jogo, e essa é a diferença que cabe no bolso e na agenda de uma pessoa só.

Pensa no Brotato. O escopo de arte dele é enxuto, mas a quantidade de partidas diferentes que ele entrega é enorme, porque a variação vem da combinação de armas, itens e inimigos, não de cenários pintados um por um. Esse é o truque. Você investe seu tempo nos sistemas que geram variedade, e a variedade aparece sozinha durante o jogo. Pra quem não tem equipe de artistas nem anos de prazo, é a forma mais eficiente de transformar pouco conteúdo em muita rejogabilidade.

Os pilares pra construir um roguelike

Vale conhecer as peças antes de sair montando, porque entender o papel de cada uma economiza horas de confusão depois.

Geração procedural. É o que monta o mundo a cada partida. Pode ser o layout das salas, a forma do mapa, quais itens aparecem, qual inimigo nasce onde. Não precisa ser sofisticado pra funcionar: sortear um inimigo de uma lista já é geração procedural. O nível de complexidade cresce com o jogo, mas o princípio é sempre o mesmo, deixar o sistema decidir em vez de você fixar tudo na mão.

Aleatoriedade controlada. Roguelike é movido a sorte, mas sorte sem freio destrói o jogo. Controlar o RNG, o gerador de números aleatórios, significa garantir que o sorteio nunca produza uma combinação injogável, e que o jogador sempre tenha alguma chance. Aqui também entra o conceito de semente, ou seed: um número que alimenta o gerador e faz o resultado ser reproduzível. Mesma semente, mesma partida. Isso é ouro pra testar e pra depurar, porque você consegue repetir exatamente o cenário que deu errado. Se esse assunto é novo pra você, vale firmar a base lendo sobre aleatoriedade e RNG no Godot antes de avançar, porque é a engrenagem que move o gênero inteiro.

Inimigos em ondas ou spawn. O desafio do roguelike costuma vir do fluxo de inimigos. Eles aparecem em ondas, ou nascem em pontos do mapa conforme você avança. Esse sistema de spawn é o que mantém a tensão, e é onde boa parte da dificuldade é calibrada. Montar um spawner que solta inimigos no ritmo certo é um dos primeiros sistemas que você vai querer ter funcionando.

Itens e sinergias. Os itens são o tempero. Cada partida você pega itens diferentes, e a graça aparece quando eles combinam entre si de formas inesperadas, as sinergias. Dois itens medianos que juntos viram uma máquina de destruição: é esse momento que faz o jogador querer mais uma partida. Você não precisa de cem itens pra isso. Precisa de itens que conversem entre si.

Meta progressão. É o que fica entre partidas e dá razão pra continuar mesmo perdendo. Pode ser desbloquear armas novas, personagens, melhorias permanentes. Ela transforma a derrota em progresso e é o que segura o jogador no longo prazo.

Dificuldade que escala. Uma partida tem que ficar mais difícil conforme avança, senão vira monótona. Mais inimigos, inimigos mais fortes, ondas mais frequentes. O segredo é deixar esses números num lugar fácil de ajustar, porque calibrar a curva é trabalho de muitas tentativas.

Como começar pequeno

O erro que mais derruba projeto de roguelike é querer construir o gerador inteiro antes de ter um jogo divertido. Faça o contrário. Comece com uma única sala fixa, montada à mão, com um personagem que se move, alguns inimigos e um item pra pegar. Sem geração procedural nenhuma ainda. O objetivo é só responder uma pergunta: andar, atirar, pegar o item e enfrentar esses inimigos é divertido por conta própria?

Se a resposta for sim, você tem uma base. Se for não, nenhum gerador procedural do mundo vai salvar, porque a procedural só multiplica o que já existe. Multiplicar algo chato dá muito conteúdo chato.

Com o loop de uma sala funcionando e gostoso, aí sim você introduz variação, e de forma gradual. Primeiro, sorteie qual inimigo nasce, em vez de fixar. Depois, sorteie o item que aparece. Depois, varie o layout da sala. Um passo de cada vez, testando se continua divertido a cada adição. Sortear um item de uma lista, por exemplo, é simples assim:

extends Node

var itens: Array[String] = ["espada", "escudo", "bota", "amuleto"]

func sortear_item() -> String:
    var indice: int = randi() % itens.size()
    return itens[indice]

O randi() devolve um inteiro aleatório, e o % pega o resto da divisão pelo tamanho da lista, garantindo um índice válido. Isso já é geração procedural de item. Quando você quiser que uma partida seja reproduzível, troca o gerador global por um RandomNumberGenerator com semente:

extends Node

var rng := RandomNumberGenerator.new()

func iniciar_partida(semente: int) -> void:
    rng.seed = semente

func sortear_dano() -> int:
    return rng.randi_range(5, 15)

Guardando a semente, você consegue repetir exatamente a mesma sequência de sorteios, o que é uma mão na roda pra encontrar um bug que só acontece numa combinação específica. Com a base sólida, o próximo sistema a montar costuma ser o de inimigos, e o guia de spawn de inimigos em ondas cobre esse pedaço com calma.

Erros comuns que afundam o projeto

O primeiro já foi dito, mas merece repetição porque é o mais letal: construir o gerador procedural complexo antes de o gameplay base ser divertido. É a armadilha mais comum do gênero. A pessoa passa semanas num sistema lindo de geração de masmorras e nunca para pra checar se mover e lutar naquele jogo é gostoso. Quando descobre que não é, já gastou o fôlego todo no encanamento. Inverta sempre: diversão primeiro, geração depois.

O segundo é RNG sem controle. Aleatoriedade pura, sem regras, gera partidas injogáveis. O jogador abre a primeira sala e leva dez inimigos de uma vez, ou passa a partida inteira sem encontrar um item útil, ou recebe uma combinação que torna a vitória impossível. Sorte é o tempero do gênero, mas sorte sem freio é frustração. Sempre coloque limites: um mínimo de itens úteis, um teto de inimigos por onda, regras que impeçam o pior caso. O jogador tem que sentir que perdeu por uma decisão, não por um sorteio cruel que ele não tinha como contornar.

O terceiro é escopo. O gênero tenta te seduzir a adicionar mais um item, mais um inimigo, mais um sistema, infinitamente. Resista no começo. Um roguelike pequeno e redondo, com poucas peças que combinam bem, é muito melhor que um gigante pela metade que nunca sai do papel.

Próximos passos

Você já tem o mapa: entender permadeath, partidas e procedural, montar um loop de uma sala divertido antes de qualquer gerador, e só então introduzir variação controlada com RNG, ondas de inimigos, itens com sinergia e meta progressão por cima. Esse é o esqueleto de qualquer roguelike, e tudo que você aprender depois se encaixa nele.

O próximo passo prático é hoje, e é pequeno. Abra o Godot, crie uma sala fixa com o personagem, um par de inimigos e um item no chão. Faça esse loop ficar divertido por conta própria, sem sortear nada ainda. Quando ele estiver gostoso, adicione o primeiro sorteio, o do inimigo, e sinta a partida mudar. É assim que todo roguelike começa, uma sala de cada vez. E se quiser ver até onde esse caminho leva quando alguém termina o trabalho, vale conhecer outros jogos comerciais feitos em Godot e lembrar que cada um deles, lá no comecinho, foi alguém colocando um personagem pra andar numa sala. Aqui no CursoGame.Dev a gente acredita que jogo se aprende fazendo, então comece pequeno, termine o que começar, e deixe os sistemas fazerem o trabalho pesado de gerar conteúdo por você.