Como Fazer um Jogo Tipo Geometry Dash no Godot

Como fazer um jogo tipo Geometry Dash no Godot 4 com GDScript tipado: cubo correndo sozinho, pulo num botao, giro no ar, espinhos com Area2D e restart.
Fazer um jogo tipo Geometry Dash no Godot e um otimo projeto para quem quer entender game feel sem se perder em escopo. A mecanica central cabe numa frase: o cubo corre sozinho da esquerda para a direita, voce aperta um botao para pular, e qualquer encostada num espinho reinicia tudo na hora. Nada de controlar direcao, nada de inventario, nada de menu gigante. Um botao, um ritmo, e a vontade de tentar de novo.
Neste tutorial voce monta a base jogavel com GDScript tipado de Godot 4: movimento horizontal automatico e constante, pulo com fisica num toque so, o cubo girando no ar, morte ao bater em espinhos usando Area2D e restart instantaneo. Todo o codigo aqui compila e roda de verdade, sem pseudocodigo. Se depois voce quiser explorar o mesmo esqueleto de corrida infinita, vale olhar como fazer um endless runner no Godot, que compartilha boa parte dessa estrutura.
A ideia por tras de um jogo tipo Geometry Dash
Antes de abrir o editor, entenda o truque do genero. O cubo nao escolhe para onde vai: ele se move para a direita numa velocidade fixa, o tempo todo, sem acelerar nem frear. A unica decisao do jogador e quando pular. Toda a dificuldade nasce do timing entre esse pulo e os obstaculos que aparecem no caminho.
Isso simplifica muita coisa. A camera acompanha o cubo (ou o cenario desliza, tanto faz pra base), a gravidade e sempre a mesma, o pulo e sempre igual, e os espinhos ficam parados esperando. Previsibilidade aqui nao e defeito, e requisito: o jogador precisa aprender o padrao e executar com precisao. Um pulo que varia de altura destroi o jogo.
A cena principal pode ficar assim:
Main (Node2D)
├── Cubo (CharacterBody2D)
│ ├── Sprite2D
│ └── CollisionShape2D
├── Chao (StaticBody2D)
│ └── CollisionShape2D
├── Obstaculos (Node2D)
└── CanvasLayer
└── LabelMorreu (Label)
O Chao e um StaticBody2D porque o cubo precisa pisar nele de verdade. Ja os espinhos, que veremos adiante, usam Area2D, porque com eles nao queremos colisao fisica, so detectar o toque.
O cubo que corre e pula sozinho
Comece pelo coracao do jogo: o movimento. Adicione um CharacterBody2D chamado Cubo, com um Sprite2D quadrado e um CollisionShape2D retangular. O cubo cai por gravidade manual, anda para a direita sempre na mesma velocidade e sobe uma unica vez quando o jogador aperta o botao, desde que esteja no chao.
Primeiro defina uma acao de input. Em Projeto, Configuracoes do Projeto, Mapa de Entrada, crie uma acao chamada pular e associe a ela a barra de espaco, o clique do mouse e, se quiser, o toque na tela. Assim o mesmo codigo responde a teclado, mouse e celular.
Agora o script do cubo:
extends CharacterBody2D
@export var velocidade_x: float = 400.0
@export var forca_pulo: float = 600.0
@export var gravidade: float = 1800.0
@export var giro_no_ar: float = 6.0
func _physics_process(delta: float) -> void:
# Movimento horizontal sempre constante
velocity.x = velocidade_x
# Gravidade manual, somada frame a frame
velocity.y += gravidade * delta
# Pulo so acontece com os pes no chao
if is_on_floor() and Input.is_action_just_pressed("pular"):
velocity.y = -forca_pulo
move_and_slide()
girar(delta)
Repare que velocity.x nunca muda: o cubo corre para a direita a 400 pixels por segundo e ponto. A gravidade acumula na velocity.y a cada frame, puxando o cubo para baixo. O pulo so dispara quando duas condicoes batem ao mesmo tempo: o cubo esta no chao (is_on_floor()) e o jogador acabou de apertar (is_action_just_pressed). Isso evita pulo duplo e pulo no ar, exatamente como no Geometry Dash.
O cubo girando no ar
O giro e o detalhe que da a identidade visual do genero. Enquanto o cubo esta no ar, ele roda; quando pousa, ele para reto. A funcao girar, chamada la no fim do _physics_process, cuida disso:
func girar(delta: float) -> void:
if not is_on_floor():
# Gira continuamente enquanto esta no ar
rotation += giro_no_ar * delta
else:
# Ao pousar, alinha ao multiplo de 90 graus mais proximo
var passo: float = PI / 2.0
rotation = round(rotation / passo) * passo
No ar, somamos giro_no_ar * delta na rotation do no, o que gira o cubo numa velocidade constante independente da taxa de quadros. Quando is_on_floor() volta a ser verdadeiro, arredondamos a rotacao para o multiplo de 90 graus mais proximo (PI / 2.0 em radianos). Assim o cubo sempre aterrissa com um dos lados virado para baixo, nunca torto. E um ajuste pequeno que muda totalmente a sensacao do jogo.
Espinhos que matam na hora, com Area2D
Agora os obstaculos. No Geometry Dash, encostar num espinho significa morte imediata e recomeco. A ferramenta certa para isso e a Area2D, porque ela nao empurra nem bloqueia o cubo, so avisa quando algo entrou nela. Monte uma cena de espinho separada para reaproveitar:
Espinho (Area2D)
├── Sprite2D
└── CollisionShape2D
No CollisionShape2D, use um ConvexPolygonShape2D em formato de triangulo, para o toque so contar quando o cubo realmente encostar na ponta. Conecte o sinal body_entered da Area2D a um script. Esse sinal dispara quando um corpo fisico (o nosso CharacterBody2D) entra na area:
extends Area2D
func _ready() -> void:
body_entered.connect(_ao_tocar)
func _ao_tocar(corpo: Node2D) -> void:
if corpo.is_in_group("jogador"):
morrer()
func morrer() -> void:
get_tree().reload_current_scene()
Para o if funcionar, adicione o cubo ao grupo jogador (no painel No, aba Grupos, ou por codigo com add_to_group("jogador") no _ready). Assim o espinho so mata o jogador, e nao outro espinho ou um obstaculo qualquer que por acaso encoste nele.
A morte aqui e deliberadamente simples: reload_current_scene() recarrega a fase inteira do zero, o que da o restart instantaneo que o genero exige. Nao ha animacao de game over, nao ha menu: errou, voltou ao inicio, tenta de novo. Esse loop curtissimo entre tentativa e recomeco e o que vicia no Geometry Dash. Se quiser um restart ainda mais rapido depois, voce guarda a posicao inicial e so reposiciona o cubo, em vez de recarregar tudo, mas reload_current_scene ja resolve bem a base.
Obstaculos vindos do cenario
Com a cena de espinho pronta, montar o nivel e questao de posicionar instancias ao longo do caminho. Para um primeiro prototipo, voce pode simplesmente arrastar varios espinhos para dentro do no Obstaculos, espalhados no eixo X, cada um numa distancia diferente. Como o cubo anda para a direita a velocidade constante, ele vai encontrar um obstaculo atras do outro, e cabe ao jogador acertar o pulo em cada um.
Se preferir gerar os espinhos por codigo em vez de arrastar na mao, da para instanciar a partir da cena salva:
extends Node2D
@export var cena_espinho: PackedScene
@export var posicoes_x: Array[float] = [600.0, 1000.0, 1300.0, 1800.0]
func _ready() -> void:
for x: float in posicoes_x:
var espinho: Area2D = cena_espinho.instantiate()
espinho.position = Vector2(x, 500.0)
add_child(espinho)
Cada valor em posicoes_x vira um espinho no chao, na altura y de 500. Mudar essa lista muda o nivel inteiro. E a forma mais direta de desenhar uma fase: voce pensa em termos de coordenadas, e a distancia entre os numeros define o ritmo da corrida.
Sincronizar o nivel com a batida da musica
Aqui esta o que separa um auto-runner qualquer de um jogo de ritmo de verdade: no Geometry Dash, os obstaculos caem exatamente nas batidas da trilha sonora. Essa parte e a mais trabalhosa e, com honestidade, nao se resolve em poucas linhas. Mas a ideia central e simples de entender.
Como o cubo anda a velocidade constante, existe uma relacao direta entre tempo e posicao. Se o cubo faz 400 pixels por segundo e uma batida da musica acontece a cada 0,5 segundo, entao cada batida corresponde a 200 pixels de distancia. Para alinhar um obstaculo a uma batida, voce o coloca no x que o cubo vai alcancar no instante daquela batida:
@export var bpm: float = 120.0
func x_da_batida(numero_da_batida: int) -> float:
var segundos_por_batida: float = 60.0 / bpm
var tempo: float = numero_da_batida * segundos_por_batida
return velocidade_x * tempo
Com x_da_batida, voce transforma o numero de uma batida na coordenada horizontal onde o obstaculo deve ficar. Para sincronia mais fina, toque a musica com um AudioStreamPlayer e compare o design com get_playback_position(), ajustando os espinhos ate que o pulo caia na batida. O caminho realista e: construa o nivel fixo primeiro, deixe o jogo gostoso de jogar, e so depois amarre o posicionamento na trilha. Sincronia vem por ultimo, nunca primeiro.
Honestidade sobre o escopo
O que voce tem ao fim deste tutorial e uma base jogavel, nao um Geometry Dash completo, e e justo deixar isso claro. O cubo corre, pula num botao, gira no ar, morre nos espinhos e reinicia na hora. Isso ja e um prototipo que roda e que diverte, e e exatamente onde todo jogo desse tipo comeca.
O que fica para as proximas camadas: fases longas com checkpoints, outros tipos de obstaculo alem do espinho, os modos de nave e gravidade invertida, um editor de niveis e a sincronia fina com a musica. Cada uma dessas coisas entra em cima do esqueleto que voce montou aqui, sem jogar fora nada do que ja existe.
Se a parte de pulo e colisao te interessou e voce quer levar a fisica do personagem adiante, o tutorial de jogo de plataforma no Godot aprofunda movimento, chao e salto num contexto maior. E se a sua praia for mesmo o loop curto de corrida e reacao rapida, o passo a passo do Flappy Bird no Godot pratica a mesma logica de um toque, uma acao, com um outro visual. A melhor forma de aprender o genero e terminar esta base, sentir o game feel na mao, e so entao decidir qual camada construir depois.
Perguntas frequentes
Qual no eu uso pro cubo do Geometry Dash na Godot?
Use CharacterBody2D. Voce controla a gravidade na mao, pela velocity.y, e sabe exatamente o que acontece a cada frame. Para um auto-runner de ritmo isso e o ideal, porque o pulo precisa ser sempre igual: mesma forca, mesma altura, mesmo tempo no ar. Com RigidBody2D a fisica fica imprevisivel e o jogo deixa de ser justo.
O cubo anda sozinho ou eu controlo a direcao?
Ele anda sozinho. No genero do Geometry Dash a velocidade horizontal e automatica e constante: voce so decide a hora de pular. Isso significa que velocity.x e sempre o mesmo valor fixo e o jogador tem um botao unico para apertar. Toda a dificuldade vem do timing do pulo contra os obstaculos.
Como faco o cubo girar enquanto esta no ar?
Voce soma um valor na rotation do no a cada frame enquanto o cubo nao esta no chao, usando delta para o giro ficar igual em qualquer taxa de quadros. Quando ele toca o chao de novo, voce arredonda a rotacao para o multiplo de 90 graus mais proximo, para o cubo sempre pousar reto como no jogo original.
Por que uso Area2D nos espinhos em vez de um corpo solido?
Porque eu so quero detectar o toque e matar o jogador, nao empurrar nem bloquear o cubo. A Area2D dispara o sinal body_entered quando o CharacterBody2D do cubo encosta, e isso basta para chamar a morte e reiniciar. Um corpo solido tentaria colidir fisicamente, o que atrapalharia o movimento constante.
Da pra sincronizar o nivel com a musica de verdade?
Da, mas e a parte mais trabalhosa. A base e posicionar os obstaculos nas coordenadas que correspondem as batidas, calculando a distancia pela velocidade do cubo e pelo tempo de cada batida. Para precisao de verdade voce le a posicao do tocador de audio com AudioStreamPlayer e alinha o design a ela. Comece com o nivel fixo e so depois amarre na musica.
Esse tutorial entrega um Geometry Dash completo?
Nao, e honesto dizer que entrega a base jogavel: cubo correndo, pulo num botao, giro no ar, morte nos espinhos e restart instantaneo. Isso ja e um prototipo que roda e diverte. Fases longas, editor de niveis, varios modos de nave e a sincronia fina com a trilha sao camadas que voce adiciona depois, em cima dessa base.


