Voltar para o Blog
Quest Log

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

Cozinha vista de cima em pixel art, com estações de corte e fogão, pratos em preparo e pedidos pendurados com cronômetros correndo

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.

Ferramenta:Godot

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.

Curso de Godot
Quer fazer seu primeiro jogo na Godot?

No curso de Godot da CursoGame.Dev você vai do zero ao primeiro jogo, com um desafio prático em cada level e suporte individual no WhatsApp quando travar.

Conhecer o curso de Godot
Suporte no WhatsAppAcesso vitalícioGarantia de 7 dias

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.