Como Fazer um Jogo de Sobrevivência no Godot (Guia Iniciante)

Como fazer um jogo de sobrevivência: por onde o gênero começa

Aprender como fazer um jogo de sobrevivência é menos sobre um truque mágico e mais sobre entender que o gênero é um conjunto de sistemas pequenos que empurram o jogador o tempo todo. Fome que cai, energia que acaba, noite que chega, inimigo que aparece: cada um desses é uma engrenagem simples. O que assusta iniciante não é a dificuldade de cada peça, e sim a quantidade delas e a vontade de ligar todas de uma vez. Neste guia a gente separa os pilares do survival, mostra os sistemas centrais, dá dois exemplos de código GDScript tipado na Godot 4 e, principalmente, explica como não afundar no escopo.

A boa notícia: a Godot 4 é uma engine gratuita, leve e com uma linguagem própria (GDScript) que lembra Python. Ela é perfeita pra prototipar survival, porque você monta uma cena, pluga um script tipado e já tem fome decaindo na tela em minutos.

Os quatro pilares de um jogo de sobrevivência

Antes de escrever qualquer linha de código, vale entender o que faz um jogo ser "de sobrevivência" na cabeça do jogador. São quatro forças que precisam existir juntas:

1. Recursos escassos. Comida, água, madeira, munição. Se sobra de tudo, não existe sobrevivência, existe passeio. A escassez é o que gera decisão.
2. Ameaça constante. Pode ser fome, frio, monstros à noite ou um relógio correndo. A ameaça é o que transforma cada recurso em algo valioso.
3. Progressão. O jogador precisa sentir que fica mais forte: crafta uma ferramenta melhor, constrói um abrigo, desbloqueia uma área. Sem progressão, a tensão vira frustração.
4. Permadeath opcional. A morte permanente dá peso às decisões, mas é uma escolha de design, não uma regra. Você pode ter checkpoints. O importante é que a morte custe algo.

Guarde esses quatro pilares. Toda vez que você for adicionar uma mecânica, pergunte a qual pilar ela serve. Se não serve a nenhum, provavelmente é escopo extra que você não precisa agora.

Os sistemas centrais que você vai construir

Traduzindo os pilares em código, um survival costuma ter estes sistemas. Você não precisa de todos no primeiro protótipo, mas é bom conhecer o mapa:

• Necessidades (fome, sede, energia). Barras que caem com o tempo e forçam o jogador a agir. É o coração do gênero e o mais fácil de programar.
• Inventário. Onde os recursos coletados ficam. Comece com uma lista simples, não com uma grade arrastável cheia de ícones.
• Coleta de recursos. O jogador interage com uma árvore, uma pedra, um arbusto e ganha um item. Simples de fazer, essencial pro loop.
• Crafting básico. Combinar itens em algo novo: madeira mais pedra vira machado. No começo, uma ou duas receitas bastam.
• Ciclo dia/noite. Muda a iluminação e, mais importante, muda a ameaça. À noite os inimigos aparecem ou a temperatura cai.
• Spawn de inimigos. A pressão externa. Pode ser um zumbi que surge no escuro ou um animal que ataca se você chegar perto.

Repare que cada sistema é uma engrenagem que alimenta a outra: a fome empurra você a coletar, a coleta enche o inventário, o inventário permite craftar, o crafting ajuda a sobreviver à noite. Esse encadeamento é o "loop de sobrevivência". Se o loop gira, seu jogo funciona, mesmo feio.

Código: uma barra de necessidade que decai com delta

Vamos ao primeiro sistema, o mais importante: uma necessidade que cai com o tempo. O segredo é multiplicar o consumo por delta, o tempo do último quadro. Assim a fome cai na mesma velocidade num PC lento e num rápido.

Crie um nó (por exemplo um Node chamado Necessidades) e cole este script tipado:

extends Node

var fome: float = 100.0
var energia: float = 100.0

var consumo_fome: float = 2.0
var consumo_energia: float = 1.0

signal fome_zerada

func _process(delta: float) -> void:
    fome -= consumo_fome * delta
    energia -= consumo_energia * delta

    fome = clampf(fome, 0.0, 100.0)
    energia = clampf(energia, 0.0, 100.0)

    if fome <= 0.0:
        fome_zerada.emit()

func comer(quantidade: float) -> void:
    fome = clampf(fome + quantidade, 0.0, 100.0)

O que está acontecendo aqui: consumo_fome de 2.0 significa que a fome cai 2 pontos por segundo, independente da taxa de quadros, graças ao delta. O clampf impede que os valores passem de 0 ou 100. Quando a fome zera, o signal fome_zerada dispara e você conecta isso ao que quiser (perder vida, tela de morte, o que fizer sentido). O método comer é chamado quando o jogador consome comida do inventário.

Ligar essa barra a um ProgressBar da interface é só atualizar o valor no _process. Não complique: fome, energia e talvez sede já dão a sensação de sobrevivência.

Código: coleta simples de recurso

O segundo sistema é a coleta. A ideia: o jogador aperta uma tecla perto de um objeto e ganha um item. Aqui usamos uma Area2D chamada Recurso (uma árvore, por exemplo) com um script tipado. Quando o jogador está dentro da área e aperta a ação de interagir, o recurso entrega madeira e some.

extends Area2D

@export var tipo_item: String = "madeira"
@export var quantidade: int = 1

var jogador_por_perto: bool = false

signal coletado(item: String, qtd: int)

func _ready() -> void:
    body_entered.connect(_ao_entrar)
    body_exited.connect(_ao_sair)

func _ao_entrar(corpo: Node2D) -> void:
    if corpo.is_in_group("jogador"):
        jogador_por_perto = true

func _ao_sair(corpo: Node2D) -> void:
    if corpo.is_in_group("jogador"):
        jogador_por_perto = false

func _process(_delta: float) -> void:
    if jogador_por_perto and Input.is_action_just_pressed("interagir"):
        coletado.emit(tipo_item, quantidade)
        queue_free()

Os detalhes que importam: @export deixa você definir o tipo e a quantidade do item direto no editor, então a mesma cena de recurso serve pra madeira, pedra ou fruta só mudando os campos. O jogador precisa estar no grupo jogador (você adiciona isso pelo painel de grupos ou por código). A ação interagir você cadastra em Projeto > Configurações do Projeto > Mapa de Entradas. Quando coleta, o signal coletado avisa o inventário e o queue_free remove o recurso da cena.

Com esses dois scripts você já tem meio survival: algo que te pressiona (a fome) e algo que alivia a pressão (coletar recurso pra depois comer). Esse é o loop mínimo. Tudo o mais é tempero.

Comece pequeno: o escopo é o verdadeiro chefão

Aqui está o conselho mais importante do post, e o mais ignorado por iniciante. O gênero survival é um ímã de escopo. Você começa querendo fome e coleta, e três dias depois está pesquisando geração procedural de mundo aberto, multiplayer e uma árvore de crafting com cem itens. O jogo nunca sai.

O corte certo pra um primeiro projeto:

• Uma tela ou um mapa pequeno. Nada de mundo infinito. Uma clareira com árvores e pedras basta.
• Uma ou duas necessidades. Fome sozinha já ensina o loop. Adicione energia se sobrar fôlego.
• Três ou quatro recursos. Madeira, pedra, fruta. Chega.
• Uma receita de crafting. Madeira mais pedra vira machado, e o machado coleta mais rápido. Pronto, você tem progressão.
• Uma ameaça. Um inimigo simples que aparece à noite, ou só a própria fome. Não precisa de IA sofisticada.

Se você fechar esse escopo, termina um jogo. E um jogo terminado, mesmo pequeno, ensina mais que dez projetos abandonados. Depois você expande em cima de uma base que funciona.

Erros de escopo comuns (e como escapar deles)

Alguns tropeços que aparecem em quase todo primeiro survival:

• Sistemas antes do loop. Gente que passa semanas num inventário arrastável perfeito sem ter fome funcionando. Faça o loop girar primeiro, poli depois.
• Arte antes de mecânica. Sprites bonitos não fazem o jogo divertido. Use quadrados coloridos até a mecânica agradar. Vale lembrar que dá pra montar bons visuais com poucos recursos, inclusive integrando sistemas de ambiente como um sistema de clima com chuva na Godot quando o núcleo já estiver de pé.
• Copiar um AAA. Seu primeiro survival não é Rust nem Valheim. É um protótipo. Tratar como protótipo tira o peso das costas.
• Números no chute. Consumo de fome, dano de inimigo, quantidade de recurso: teste e ajuste jogando. Balanceamento é iteração, não adivinhação.
• Ignorar a estrutura do projeto. Organize cenas e scripts desde o começo. Um Node de necessidades, uma cena de recurso reutilizável, um autoload pro inventário. Isso evita que o código vire um nó cego.

Se você olhar outros gêneros baseados em loop e ameaça, muita coisa se repete. Um jogo tower defense na Godot, por exemplo, também vive de recursos, ondas de inimigos e progressão. Estudar gêneros vizinhos acelera seu entendimento do survival.

Por que a Godot 4 combina com survival

Vale um parágrafo sobre a ferramenta. A Godot é gratuita e de código aberto, sem royalties nem licença. O sistema de nós e cenas facilita reaproveitar recursos (uma cena de árvore vira dezenas de árvores). O GDScript tipado, como você viu nos exemplos, é enxuto e roda direto na engine. Pra 2D ela é excelente, e o 3D amadureceu bastante na versão 4. Se você ainda está decidindo entre engines, dá uma olhada nesta comparação completa entre Godot e Unity antes de fechar a escolha; pra um solo iniciante focado em survival 2D, a Godot dificilmente vai te atrapalhar.

Do protótipo ao jogo de verdade

Recapitulando o caminho de como fazer um jogo de sobrevivência sem se perder: entenda os quatro pilares (recursos, ameaça, progressão, permadeath opcional), monte o loop mínimo com uma necessidade que decai e uma coleta simples, e só depois adicione inventário, crafting, ciclo dia/noite e inimigos, um sistema por vez. O código tipado que você viu aqui já é suficiente pra sentir o gênero na prática.

A diferença entre quem termina um survival e quem acumula pastas de projetos abandonados quase nunca é talento. É método: escopo pequeno, loop primeiro, iteração constante. Se você quer aprender esse método com estrutura, do zero até publicar, o curso de criação de jogos para iniciantes da CursoGame.Dev te leva pela mão por cada um desses sistemas, sem pular a parte chata que é justamente a que faz o jogo existir. Abra a Godot, crie a barra de fome e comece hoje pelo loop. O resto vem em cima.