Como Fazer um Jogo de Culinária (Tipo Overcooked)

Como fazer um jogo de culinária tipo Overcooked na Godot 4: pedidos com timer, estações de preparo, pegar ingredientes com Area2D e pontuação.
Quando alguém me pergunta como fazer um jogo de culinária tipo Overcooked, a primeira coisa que eu explico é que o gênero não é sobre cozinhar. É sobre pressão de tempo. O prato é só a desculpa. O que faz o jogador suar é o pedido piscando na tela, a estação ocupada, o ingrediente na mão errada e o cronômetro correndo. Se você entender isso cedo, constrói o jogo certo. Se não entender, gasta semanas modelando comida bonita num jogo que não tem tensão nenhuma.
Neste guia eu desmonto um jogo de gestão de tempo nos sistemas que o sustentam e mostro código real na Godot 4, com GDScript tipado. A meta não é clonar o Overcooked inteiro, com multiplayer e quarenta fases. É te dar o núcleo que funciona: pedidos que chegam com timer, estações que transformam ingredientes, interação pra pegar e largar, montagem da receita na ordem certa e uma pontuação que recompensa quem serve rápido e pune quem atrasa.
Por que "como fazer um jogo de culinária" engana no escopo
O gênero parece pequeno porque cada peça é simples. Um timer é fácil. Uma estação é fácil. Pegar um objeto é fácil. A dificuldade mora na quantidade de peças rodando ao mesmo tempo e conversando entre si. O pedido precisa saber quais ingredientes exige. O ingrediente precisa saber em que estado está, cru ou cortado ou cozido. A estação precisa saber o que aceita e o que devolve. O prato precisa comparar o que recebeu com o que o pedido pedia. E tudo isso acontece enquanto três ou quatro cronômetros correm.
Overcooked foi feito pelo Ghost Town Games, um estúdio de duas pessoas, com ajuda externa em arte e som. Eu não trago esse fato pra te animar, trago pra calibrar a régua: eram dois profissionais experientes, e ainda assim o jogo é um relógio suíço de sistemas afinados. Seu primeiro protótipo não precisa chegar lá. Precisa fechar o loop uma vez, com uma receita, e provar que a tensão funciona. A partir disso, crescer é adicionar dados, não reescrever a base.
A saída, como em todo projeto, é fatiar. Uma cozinha, uma receita de dois passos (cortar e cozinhar), um balcão de entrega e um timer por pedido. Esse recorte já é um jogo. Se ele for divertido com uma receita, vai ser divertido com dez. Se for chato com uma, mais receitas não salvam.
O pedido como classe com timer
O coração do jogo é o pedido. Ele define o que o jogador precisa montar e quanto tempo tem pra isso. Modelar o pedido como uma classe própria deixa o resto do código limpo, porque cada pedido carrega seu próprio estado.
class_name Pedido
extends RefCounted
var ingredientes_exigidos: Array[String] = []
var tempo_total: float = 45.0
var tempo_restante: float = 45.0
var servido: bool = false
func _init(receita: Array[String], tempo: float) -> void:
ingredientes_exigidos = receita
tempo_total = tempo
tempo_restante = tempo
func atualizar(delta: float) -> void:
if servido:
return
tempo_restante -= delta
func expirou() -> bool:
return tempo_restante <= 0.0 and not servido
func confere_prato(prato: Array[String]) -> bool:
if prato.size() != ingredientes_exigidos.size():
return false
var copia_exigida: Array[String] = ingredientes_exigidos.duplicate()
for item in prato:
if item in copia_exigida:
copia_exigida.erase(item)
else:
return false
return copia_exigida.is_empty()
Repare no confere_prato. Ele compara o que o jogador montou com o que o pedido pedia, sem se importar com a ordem em que os ingredientes entraram no prato, só com o conjunto final. Isso é uma decisão de design: no Overcooked, a sopa não liga se você picou a cebola antes ou depois do tomate, ela liga se os dois estão lá. Usar duplicate e ir removendo evita o bug clássico de aceitar um prato com ingredientes repetidos a mais.
O gerenciador que cria e expira pedidos
Com a classe pronta, você precisa de alguém que fabrique pedidos de tempos em tempos, atualize os cronômetros e remova os que morreram. Esse é o gerenciador, um Node que vive na cena e empurra o ritmo do jogo.
extends Node
signal pedido_criado(pedido: Pedido)
signal pedido_expirado(pedido: Pedido)
var pedidos_ativos: Array[Pedido] = []
var intervalo_spawn: float = 12.0
var _contador: float = 0.0
var cardapio: Array[Array] = [
["cebola_cortada", "cebola_cortada"],
["carne_cozida", "pao"],
]
func _process(delta: float) -> void:
_contador += delta
if _contador >= intervalo_spawn:
_contador = 0.0
_criar_pedido()
for pedido in pedidos_ativos:
pedido.atualizar(delta)
# iterar de tras pra frente pra remover com seguranca
for i in range(pedidos_ativos.size() - 1, -1, -1):
if pedidos_ativos[i].expirou():
pedido_expirado.emit(pedidos_ativos[i])
pedidos_ativos.remove_at(i)
func _criar_pedido() -> void:
var receita: Array = cardapio.pick_random()
var tipado: Array[String] = []
for item in receita:
tipado.append(item)
var novo: Pedido = Pedido.new(tipado, 45.0)
pedidos_ativos.append(novo)
pedido_criado.emit(novo)
O detalhe que salva de um crash é remover os pedidos iterando de trás pra frente. Se você percorre a lista do começo ao fim removendo itens no meio, os índices dançam e você pula elementos ou estoura o array. Os dois sinais, pedido_criado e pedido_expirado, deixam a interface reagir sem o gerenciador precisar conhecer a UI. A HUD escuta pedido_criado e desenha um card novo com o cronômetro, escuta pedido_expirado e pisca vermelho antes de sumir.
Ingrediente com estado e a estação como máquina de estados
Um ingrediente não é uma coisa só, ele passa por transformações. A cebola começa crua, vira cortada na tábua, e só então serve no prato. Modelar isso com um nome e um estado basta pro protótipo.
class_name Ingrediente
extends Area2D
@export var tipo_base: String = "cebola"
var estado: String = "cru"
var sendo_carregado: bool = false
func nome_completo() -> String:
if estado == "cru":
return tipo_base
return tipo_base + "_" + estado
A estação é onde o estado muda, e ela é o melhor lugar do jogo pra usar uma máquina de estados explícita. Uma tábua de corte, por exemplo, tem três situações: parada esperando ingrediente, processando (o corte leva tempo) e pronta com o resultado. Tratar isso com um enum deixa o comportamento claro e fácil de depurar.
class_name Estacao
extends Area2D
enum Fase { OCIOSA, PROCESSANDO, PRONTA }
@export var transforma_de: String = "cru"
@export var transforma_para: String = "cortado"
@export var duracao: float = 3.0
var fase: Fase = Fase.OCIOSA
var _tempo: float = 0.0
var ingrediente_atual: Ingrediente = null
func receber(ing: Ingrediente) -> bool:
if fase != Fase.OCIOSA:
return false
if ing.estado != transforma_de:
return false
ingrediente_atual = ing
fase = Fase.PROCESSANDO
_tempo = 0.0
return true
func _process(delta: float) -> void:
if fase != Fase.PROCESSANDO:
return
_tempo += delta
if _tempo >= duracao:
ingrediente_atual.estado = transforma_para
fase = Fase.PRONTA
func retirar() -> Ingrediente:
if fase != Fase.PRONTA:
return null
var pronto: Ingrediente = ingrediente_atual
ingrediente_atual = null
fase = Fase.OCIOSA
return pronto
Essa mesma classe serve pra tábua e pra fogão, você só muda os exports no editor: a tábua transforma cru em cortado em três segundos, o fogão transforma cortado em cozido em cinco. Um design, dois comportamentos, zero código duplicado. É o mesmo princípio de reaproveitar dados por recurso que aparece em qualquer jogo 2D bem estruturado na Godot.
Pegar e largar com Area2D
A interação é o que amarra tudo. O jogador anda pela cozinha, chega perto de uma estação ou de uma caixa de ingredientes, aperta um botão e pega ou larga. A forma mais direta de saber o que está ao alcance é dar ao jogador uma Area2D de interação e deixar os corpos entrarem e saírem dela.
extends CharacterBody2D
@export var velocidade: float = 180.0
var carregando: Ingrediente = null
var alcance: Array[Area2D] = []
func _ready() -> void:
$AreaInteracao.area_entered.connect(_ao_entrar)
$AreaInteracao.area_exited.connect(_ao_sair)
func _ao_entrar(area: Area2D) -> void:
alcance.append(area)
func _ao_sair(area: Area2D) -> void:
alcance.erase(area)
func _physics_process(delta: float) -> void:
var dir: Vector2 = Input.get_vector("esquerda", "direita", "cima", "baixo")
velocity = dir * velocidade
move_and_slide()
func _unhandled_input(event: InputEvent) -> void:
if event.is_action_pressed("interagir"):
_interagir()
func _interagir() -> void:
for area in alcance:
if area is Estacao:
_lidar_com_estacao(area)
return
if area is Ingrediente and carregando == null:
carregando = area
area.sendo_carregado = true
return
func _lidar_com_estacao(estacao: Estacao) -> void:
if carregando != null:
if estacao.receber(carregando):
carregando = null
else:
var pronto: Ingrediente = estacao.retirar()
if pronto != null:
carregando = pronto
A lógica do _interagir é a regra do jogo em miniatura. Se você tem algo na mão e está perto de uma estação, tenta depositar. Se está de mãos vazias perto de uma estação pronta, retira o resultado. Se está de mãos vazias perto de uma caixa de ingrediente, pega um novo. Cada return garante que uma ação acontece por aperto de botão, sem pegar e largar no mesmo frame. Pra montar o visual, basta reposicionar o ingrediente carregado acima do jogador a cada frame, ou torná-lo filho do personagem enquanto sendo_carregado for verdadeiro.
Servir o prato, pontuar e penalizar
O balcão de entrega fecha o loop. Ele é mais uma Area2D, mas em vez de transformar ingredientes, ele compara o prato montado com os pedidos ativos e manda o resultado pro placar.
extends Node
var pontuacao: int = 0
func entregar(prato: Array[String], gerenciador: Node) -> void:
for i in range(gerenciador.pedidos_ativos.size()):
var pedido: Pedido = gerenciador.pedidos_ativos[i]
if pedido.confere_prato(prato):
pedido.servido = true
var bonus: int = int(pedido.tempo_restante)
pontuacao += 20 + bonus
gerenciador.pedidos_ativos.remove_at(i)
return
# nenhum pedido batia: prato errado
pontuacao -= 5
func penalizar_atraso() -> void:
pontuacao -= 15
Aqui aparece a regra que dá alma ao gênero: quem serve rápido ganha mais. O bônus é o tempo que sobrava no pedido convertido em pontos, então deixar um prato esperando no balcão custa placar mesmo que você acerte a receita. O prato errado tira pouco, pra punir sem travar o jogador. E a penalidade de atraso, disparada quando o gerenciador emite pedido_expirado, é o que cria o medo de deixar um pedido morrer. Ligue penalizar_atraso ao sinal pedido_expirado no _ready da cena e o círculo está fechado: pedido nasce, corre o tempo, é servido ou expira, o placar reage.
A ordem de construção que eu seguiria
Se eu começasse esse jogo hoje, não abriria modelando comida. Começaria pelo Pedido e pelo gerenciador, com um print no lugar da HUD, só pra ver pedidos nascendo e expirando no console. Depois faria o jogador andar e a Area2D de interação funcionar com uma caixa de ingrediente e um balcão, pulando as estações: pega a cebola crua, entrega crua, acerta o pedido. Com o loop fechando de ponta a ponta, aí sim entram as estações e o estado dos ingredientes, que é a camada de dificuldade. HUD, arte e áudio vêm por último, quando o jogo já é jogável feio.
Esse caminho também te prepara pra sistemas vizinhos sem reescrever nada. Um sistema de craft com receitas é o mesmo confere_prato olhando pra uma tabela maior, e a lógica de estações e transformação de recursos conversa direto com a de um jogo de fazenda, onde o ingrediente cru vem do plantio em vez da caixa. São gêneros diferentes rodando sobre os mesmos ossos: dados em classes, estados explícitos e sinais ligando as peças.
O jogo de culinária é um ótimo projeto pra aprender justamente por isso. Ele te força a pensar em sistemas que conversam, mas cada sistema sozinho é pequeno o bastante pra você testar num dia. Faça a cozinha de uma receita funcionar, sinta a tensão do cronômetro, e você vai saber, na mão, o que faz esse gênero divertido antes de investir meses nele.
Perguntas frequentes
Dá pra fazer um jogo tipo Overcooked sozinho na Godot?
Dá, desde que você respeite o escopo. Uma fatia jogável com uma estação de corte, um fogão, um tipo de pedido e um balcão de entrega sai em algumas semanas de trabalho consistente. O que explode o cronograma é o multiplayer local, o caos de várias receitas simultâneas e o level design das cozinhas malucas. Comece com uma receita só e um timer, feche o loop, e cresça a partir dali.
Preciso de física pra fazer um jogo de culinária?
Não precisa de física complexa. O gênero é de gestão de tempo e posicionamento, não de simulação. Movimento simples com velocity, detecção de proximidade com Area2D e uma máquina de estados por estação resolvem o núcleo inteiro. Você só encosta em física se quiser ingredientes que escorregam ou pratos que caem, e isso é tempero, não fundação.
Como funciona o timer dos pedidos?
Cada pedido guarda um tempo restante que decresce a cada frame no _process. Quando chega a zero sem ser entregue, o pedido conta como atrasado e aplica penalidade na pontuação. O jeito mais limpo é cada Pedido ser uma classe própria com seu tempo_restante, e um gerenciador que cria pedidos novos em intervalos e remove os que expiram ou foram servidos.
Qual a parte mais difícil de um jogo tipo Overcooked?
Não é o código das estações, é o balanceamento e o level design. Decidir quantos segundos cada pedido dura, quantos pedidos aparecem por vez e como a cozinha força o jogador a se mover é o que separa um protótipo de um jogo divertido. Isso só se acerta jogando muito e ajustando números, então deixe esses valores fáceis de mexer desde o começo.
Overcooked foi feito por um time grande?
O primeiro Overcooked foi feito pelo Ghost Town Games, um estúdio de duas pessoas, com ajuda de colaboradores externos em arte e áudio. É um caso real de time minúsculo, mas não confunda isso com projeto simples: eles vinham da indústria com anos de experiência. Use o jogo como referência de design, não como medida do seu primeiro protótipo.


