Como Fazer um Jogo 2D no Godot: Roteiro do Zero ao Jogável

Aprender como fazer um jogo 2D no Godot não é decorar uma sequência de cliques. É entender um caminho: você instala a engine, cria um projeto, monta uma cena com nodes que fazem coisas específicas, escreve um pouco de código pra dar vida ao personagem e, no fim, exporta um arquivo que outras pessoas conseguem abrir. Quando esse caminho fica claro na sua cabeça, qualquer tutorial passa a fazer sentido, porque você para de copiar passos soltos e começa a enxergar a lógica por trás deles. Este roteiro é exatamente isso: o trajeto do zero até um personagem que anda e colide numa tela, usando Godot 4.

A ideia não é entregar um jogo completo dentro de um post, e sim te dar o mapa. Cada parada aqui é um conceito que você vai reusar em todo projeto que fizer daqui pra frente. Vamos do download até o botão de exportar.

Instalar o Godot e entender o que você baixou

O Godot é gratuito, de código aberto e cabe num único arquivo. Você baixa do site oficial, godotengine.org, e escolhe a versão estável mais recente da linha 4. Não tem instalador obrigatório nem cadastro: é um executável que abre direto. Coloque ele numa pasta sua e crie um atalho, porque você vai abrir bastante.

Existem duas variantes pra baixar. A versão padrão roda GDScript, que é a linguagem nativa da engine e a que vamos usar aqui. A versão chamada .NET roda também C#, e só vale a pena se você já tem certeza de que quer usar C#. Pra um primeiro jogo, pegue a padrão. Menos peças pra configurar, mais tempo fazendo o jogo. Se quiser entender essa escolha com calma depois, dá pra comparar as duas linguagens com tranquilidade, mas no começo GDScript resolve tudo.

Ao abrir, você cai no gerenciador de projetos. É uma tela que lista seus jogos e tem um botão grande de criar projeto novo. Por enquanto é só isso que importa.

Criar o projeto e a primeira cena

Clique em criar projeto, dê um nome, escolha uma pasta vazia e selecione o renderizador. Pra 2D, a opção compatível ou móvel já serve de sobra e roda em mais máquinas. Confirme e o editor abre.

Aqui aparece o primeiro conceito que muda tudo: no Godot, um jogo é feito de cenas, e cenas são feitas de nodes. Um node é uma peça que faz uma coisa só. Existe node pra mostrar imagem, node pra tocar som, node pra detectar colisão, node pra física de personagem. Você monta o jogo combinando esses blocos numa árvore, onde um node pai segura nodes filhos. Uma cena é só uma dessas árvores salva num arquivo, e ela pode ser o jogo inteiro, uma fase, um inimigo ou um botão de menu.

Essa é a grande sacada da engine. Você não programa um sistema gigante e monolítico. Você cria peças pequenas, cada uma com sua responsabilidade, e encaixa. O painel da esquerda, chamado árvore de cena, é onde você vê e organiza esses nodes. Guarde esse nome, porque é nele que a gente vai trabalhar agora.

Os nodes essenciais de um jogo 2D

Antes de mover qualquer coisa, vale conhecer os quatro nodes que aparecem em praticamente todo jogo 2D. Entender o papel de cada um economiza horas de confusão.

Node2D é a base. Todo node que existe no espaço 2D herda dele, e o que ele carrega é a transformação: posição, rotação e escala. Quando você move um Node2D, tudo que está pendurado nele se move junto. Ele não desenha nada na tela sozinho, ele só ocupa um lugar no mundo e serve de âncora pros filhos.

Sprite2D é o que mostra imagem. Você arrasta um PNG pra dentro dele e o personagem aparece na tela. Sem um Sprite2D, ou algo parecido, você tem um objeto invisível que existe mas ninguém vê. É o rosto do seu personagem.

CharacterBody2D é o corpo físico feito sob medida pra personagens controlados. Ele não é arrastado por gravidade automática como outros corpos: você decide pra onde ele vai, e a engine cuida de empurrá-lo respeitando as colisões. É ele que vai segurar a lógica de movimento do jogador. Pense nele como o esqueleto que recebe ordens.

CollisionShape2D é a forma de colisão. Sozinho ele não faz nada, mas pendurado num corpo físico ele diz onde estão as bordas daquele objeto. Um retângulo, um círculo, uma cápsula. Sem ele, o personagem atravessa o chão como fantasma, porque o jogo não sabe qual é o contorno real da coisa.

A montagem típica do jogador é assim: um CharacterBody2D como pai, e dentro dele um Sprite2D pra aparecer e um CollisionShape2D pra colidir. Os três juntos formam um personagem que se vê e se sente. Você cria essa estrutura clicando com o botão direito na árvore de cena e adicionando node por node.

Mover o personagem com GDScript tipado

Com o CharacterBody2D montado, é hora do código. Selecione o CharacterBody2D, adicione um script e o Godot abre o editor com um arquivo em branco. GDScript é a linguagem da casa, parecida com Python, e a gente vai escrever ela tipada, ou seja, dizendo o tipo de cada variável. Isso deixa o código mais claro, ajuda o editor a te avisar de erros e roda mais rápido. Se a sintaxe parecer estranha agora, ela fica natural rápido.

O movimento de um CharacterBody2D no Godot 4 gira em torno de duas coisas: a propriedade velocity, que é um vetor de pra onde o corpo está indo, e o método move_and_slide(), que move o corpo de acordo com essa velocidade e desliza pelas superfícies em vez de travar feio numa parede. O fluxo é sempre o mesmo: você calcula a velocidade, depois chama move_and_slide(). Veja um movimento de cima pra baixo, estilo top-down, onde o personagem anda nas quatro direções:

extends CharacterBody2D

var velocidade: float = 200.0

func _physics_process(delta: float) -> void:
    var direcao: Vector2 = Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")
    velocity = direcao * velocidade
    move_and_slide()

Vale ler linha por linha, porque cada uma carrega um conceito. O extends CharacterBody2D diz que esse script estende aquele node, então ele ganha acesso a velocity e move_and_slide(). A função _physics_process é chamada pela engine a cada quadro de física, num ritmo constante, e é o lugar certo pra mexer com movimento. O Input.get_vector lê as teclas de direção e devolve um Vector2 já normalizado, o que evita o clássico bug de andar mais rápido na diagonal. Multiplicamos essa direção pela velocidade e jogamos em velocity. Por fim, move_and_slide() faz o trabalho pesado de empurrar o corpo respeitando as colisões.

As ações ui_left, ui_right e companhia já vêm configuradas no Godot por padrão, ligadas às setas do teclado, então isso roda sem ajuste nenhum. Mais pra frente você cria suas próprias ações, como pulo e ataque, no mapa de entradas do projeto.

Se o seu jogo é de plataforma, com gravidade e pulo, a estrutura muda um pouco, mas a espinha é a mesma: calcular velocity, depois chamar move_and_slide(). Um exemplo enxuto:

extends CharacterBody2D

var velocidade: float = 200.0
var forca_pulo: float = -400.0
var gravidade: float = 980.0

func _physics_process(delta: float) -> void:
    if not is_on_floor():
        velocity.y += gravidade * delta

    if Input.is_action_just_pressed("ui_accept") and is_on_floor():
        velocity.y = forca_pulo

    var direcao: float = Input.get_axis("ui_left", "ui_right")
    velocity.x = direcao * velocidade

    move_and_slide()

Aqui aparece o is_on_floor(), um método que o CharacterBody2D oferece pra saber se o personagem está pisando em algo, e ele só funciona porque move_and_slide() rodou antes e guardou essa informação. A gravidade é somada ao eixo vertical quando o corpo está no ar, o pulo só dispara quando há chão sob os pés, e a força do pulo é negativa porque no 2D do Godot o Y cresce pra baixo. Repare no uso de delta na gravidade: ele é o tempo entre quadros, e multiplicar por ele mantém o movimento igual em qualquer máquina, independente da taxa de quadros. Movimento de plataforma tem muito detalhe fino além disso, como coyote time e buffer de pulo, mas a base é essa e ela já te dá um boneco que anda e salta.

Colisão: dar corpo ao mundo

Mover o personagem não adianta se ele atravessa tudo. Pra colisão funcionar, você precisa de dois lados: o personagem com seu CollisionShape2D, que a gente já montou, e o cenário com colisão própria.

O jeito mais simples de criar chão e paredes em 2D é com um StaticBody2D, que é um corpo físico que não se move, com um CollisionShape2D dentro definindo a forma sólida. Você cria uma plataforma assim e o personagem para em cima dela, porque agora os dois contornos se enxergam. Pra cenários maiores, o Godot tem o TileMapLayer, que deixa você pintar fases com blocos e gerar colisão automática a partir deles, mas pra começar um StaticBody2D com um retângulo já segura o personagem no lugar.

O ponto a guardar é o par: corpo físico mais forma de colisão. Personagem tem o seu, cenário tem o dele, e a engine resolve o encontro. Quando algo atravessa o que não deveria, quase sempre é porque faltou um CollisionShape2D ou ele está vazio, sem forma definida.

Câmera que segue o personagem

Num jogo pequeno cabe tudo numa tela, mas assim que a fase cresce você precisa de uma câmera que acompanhe o jogador. No Godot 4 isso é quase de graça: adicione um node Camera2D como filho do CharacterBody2D. Por ser filho, ele se move junto com o personagem, e a tela passa a seguir o boneco automaticamente.

A Camera2D tem opções pra suavizar o movimento, limitar até onde ela mostra e dar zoom, tudo direto no painel de propriedades, sem código. Pra um primeiro jogo, pendurar a câmera no personagem e ativar a suavização já entrega uma sensação profissional. Detalhes como zonas mortas e limites de borda você ajusta depois, conforme o jogo pedir.

Rodar, testar e exportar

Enquanto monta, você testa o tempo todo apertando o botão de play no canto superior direito, ou a tecla F5. O Godot pergunta qual é a cena principal na primeira vez, você aponta a cena do jogo, e a partir daí cada play abre o jogo numa janela. Esse ciclo de mudar algo e ver o resultado em segundos é o que torna o aprendizado tão rápido: você erra, ajusta e vê na hora.

Quando o jogo estiver jogável, vem a exportação, que é transformar o projeto num arquivo que roda sem o Godot instalado. No menu Project, em Export, você adiciona uma plataforma, como Windows, Linux ou Web. Na primeira exportação o Godot pede pra baixar os templates de exportação, um pacote único que ele instala pra você. Feito isso, escolha a pasta de saída e exporte. O resultado é um executável ou uma página web pronta pra mandar pra um amigo testar ou subir numa loja como a itch.io.

Exportar cedo é um bom hábito. Ver o jogo rodando fora do editor, na mão de outra pessoa, é o teste de realidade que mostra se aquilo virou mesmo um jogo. E quase sempre vira bem antes do que você imagina.

O caminho daqui pra frente

Você já tem o mapa inteiro: instalar, criar projeto e cena, entender os nodes essenciais, mover o personagem com GDScript tipado, colidir, seguir com a câmera e exportar. Esse é o esqueleto de qualquer jogo 2D no Godot, e tudo que você aprender daqui pra frente se encaixa nesse esqueleto.

O próximo passo não é fazer um jogo gigante. É praticar cada pedaço em projetos minúsculos. Faça um boneco que só anda. Depois um que pula. Depois um que pega uma moeda. Cada exercício pequeno consolida um conceito sem te afogar. Se o GDScript ainda parece um terreno escorregadio, vale firmar a base com o GDScript do zero antes de avançar, porque entender a linguagem destrava tudo o mais. Pra aprofundar especificamente o movimento, que é onde a sensação do jogo nasce, o guia de movimento de personagem em plataforma 2D vai além do exemplo daqui e cobre os detalhes finos que separam um pulo travado de um pulo gostoso. E se em algum momento você ficar na dúvida se o Godot é mesmo a engine certa pro seu projeto, dá pra resolver isso comparando com a alternativa mais comum na comparação completa entre Godot e Unity.

Fazer jogo é um ofício que se aprende fazendo, não lendo. Este roteiro te deu o caminho. Agora abra o Godot, crie um projeto vazio e mova um quadrado na tela. É assim que todo mundo começou, e é assim que você começa também.