Voltar para o Blog
Quest Log

Como Fazer um Jogo Tipo Among Us no Godot

Tela de jogo na Godot com personagens em uma nave espacial, um painel de tarefas e uma tela de votação de reunião de emergência

Como fazer um jogo tipo Among Us no Godot 4: papéis sorteados, tarefas, kill do impostor, reunião, votação e multiplayer com autoridade de servidor.

Ferramenta:Godot

Fazer um jogo de dedução social ensina rede, estado compartilhado e design de tensão de uma vez só, e é por isso que como fazer um jogo tipo Among Us no Godot virou uma das perguntas mais comuns de quem quer sair dos projetos solo. A boa notícia: as mecânicas de jogabilidade são simples de descrever. A parte espinhosa, e eu vou ser direto com isso o post inteiro, é o multiplayer sincronizado. Neste tutorial a gente mapeia as cinco engrenagens do gênero (papéis sorteados, tarefas, kill do impostor, reunião e votação, condição de vitória) com GDScript tipado e a API real da Godot 4, sempre com o servidor como juiz.

Antes de abrir a engine, vale ter noção do terreno. Se você nunca conectou duas instâncias de um jogo, leia primeiro o panorama de como fazer um jogo multiplayer, porque aqui eu assumo que você já sabe o que é um peer e uma RPC e vou direto na lógica do gênero.

O desenho que decide tudo: autoridade de servidor

Em um jogo de impostor, quase toda informação é secreta ou manipulável. Quem é o impostor, quem votou em quem, se a tarefa foi mesmo concluída, se o alvo estava perto o bastante para morrer: cada um desses dados é um convite para trapaça se o cliente puder decidir sozinho. A regra que organiza o projeto inteiro é a mesma de qualquer jogo online sério: o cliente pede, o servidor decide.

Na prática isso significa três coisas:

  • O cliente nunca aplica um efeito importante direto. Ele chama uma RPC pedindo ("quero matar o jogador 7", "voto no jogador 3") e espera o servidor responder.
  • O servidor valida antes de aplicar: distância, estado do jogo, papel de quem pediu, se a ação é permitida naquela fase.
  • O servidor só envia para cada cliente a informação que aquele cliente tem direito de ver. O papel de impostor vai só para o impostor. Os votos ficam escondidos até a apuração.

Guarde esse desenho. O resto do post é implementação dele.

Papéis: sortear impostor e tripulante no servidor

O sorteio acontece uma vez, quando a partida começa, e roda exclusivamente no servidor. Você pega a lista de peers conectados, embaralha e marca os primeiros como impostores. Um enum deixa o código legível:

enum Papel { TRIPULANTE, IMPOSTOR }

var _papel_por_peer: Dictionary = {}

func sortear_papeis(quantidade_impostores: int) -> void:
    if not multiplayer.is_server():
        return
    var peers: Array[int] = []
    peers.append(1)
    for id: int in multiplayer.get_peers():
        peers.append(id)
    peers.shuffle()
    for i: int in range(peers.size()):
        var papel: Papel = Papel.IMPOSTOR if i < quantidade_impostores else Papel.TRIPULANTE
        _papel_por_peer[peers[i]] = papel
        _informar_papel.rpc_id(peers[i], papel)

O detalhe que separa um clone ingênuo de um bem feito está na última linha. Usei rpc_id(peers[i], papel), que entrega o papel só para aquele peer. Se você fizesse _informar_papel.rpc(papel), todo mundo receberia o papel de todo mundo, e qualquer jogador com o jogo aberto num debugger leria quem é o impostor em dois minutos. A regra do servidor que fala pouco vale ouro aqui.

Do lado do cliente, a função que recebe é curta:

@rpc("authority", "call_remote", "reliable")
func _informar_papel(papel: Papel) -> void:
    _meu_papel = papel
    if papel == Papel.IMPOSTOR:
        hud.mostrar_aviso("Você é o impostor.")
    else:
        hud.mostrar_aviso("Você é tripulante. Complete as tarefas.")

O modo "authority" garante que só o servidor pode disparar essa RPC; um cliente que tente forjar o próprio papel chamando a função é barrado pela engine. E "call_remote" evita que ela rode no próprio servidor, que já sabe os papéis pelo Dictionary.

Tarefas: minigames simples que avançam uma barra

Tarefa, do ponto de vista de sistema, é um ponto no mapa que abre um minigame e, ao ser concluído, incrementa um contador global de progresso dos tripulantes. O minigame em si pode ser bobo (apertar botões na ordem, arrastar um fio, segurar um controle alguns segundos). O que importa para a rede é só o "concluí".

Cada ponto de tarefa é uma Area2D com um script enxuto:

extends Area2D

@export var id_tarefa: int = 0
var _jogador_perto: bool = false

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

func _ao_entrar(corpo: Node2D) -> void:
    if corpo.is_multiplayer_authority():
        _jogador_perto = true

func _ao_sair(corpo: Node2D) -> void:
    if corpo.is_multiplayer_authority():
        _jogador_perto = false

func _unhandled_input(evento: InputEvent) -> void:
    if _jogador_perto and evento.is_action_pressed("interagir"):
        abrir_minigame()

Quando o jogador termina o minigame, o cliente não marca a tarefa como feita por conta própria. Ele pede ao servidor:

func concluir_tarefa(id_tarefa: int) -> void:
    GerenciadorPartida.registrar_tarefa.rpc_id(1, id_tarefa)

E o servidor é quem valida e contabiliza. Repare que ele checa se o pedinte é tripulante (impostor fingindo fazer tarefa não conta) e se aquela tarefa ainda não tinha sido marcada por aquele peer:

@rpc("any_peer", "call_remote", "reliable")
func registrar_tarefa(id_tarefa: int) -> void:
    if not multiplayer.is_server():
        return
    var quem: int = multiplayer.get_remote_sender_id()
    if _papel_por_peer.get(quem, Papel.TRIPULANTE) == Papel.IMPOSTOR:
        return
    var chave: String = "%d:%d" % [quem, id_tarefa]
    if _tarefas_feitas.has(chave):
        return
    _tarefas_feitas[chave] = true
    _progresso_tarefas += 1
    _atualizar_barra.rpc(_progresso_tarefas, _total_tarefas)
    _checar_vitoria()

A identidade de quem pediu vem de multiplayer.get_remote_sender_id(), preenchida pela engine na camada de transporte, impossível de forjar pelo cliente. Essa é a mesma espinha dorsal de validação no servidor que sustenta jogos de arena; se quiser ver esse padrão em outro contexto, o post sobre como fazer um jogo .io multiplayer mostra a mesma ideia aplicada a movimento e colisão em massa.

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

O kill do impostor: validar distância no servidor

Aqui o apelo de confiar no cliente é maior, porque o impostor quer resposta imediata. Resista. O cliente envia a intenção de matar, e o servidor confere a distância real entre os dois personagens no seu próprio estado autoritativo, nunca na posição que o cliente afirma ter.

No cliente, o impostor aponta o alvo mais próximo e pede:

func tentar_matar(id_alvo: int) -> void:
    GerenciadorPartida.pedir_kill.rpc_id(1, id_alvo)

No servidor, a checagem decide:

const DISTANCIA_KILL: float = 80.0

@rpc("any_peer", "call_remote", "reliable")
func pedir_kill(id_alvo: int) -> void:
    if not multiplayer.is_server():
        return
    var assassino: int = multiplayer.get_remote_sender_id()
    if _papel_por_peer.get(assassino, Papel.TRIPULANTE) != Papel.IMPOSTOR:
        return
    if not _esta_vivo(assassino) or not _esta_vivo(id_alvo):
        return
    var pos_a: Vector2 = _posicao_de(assassino)
    var pos_b: Vector2 = _posicao_de(id_alvo)
    if pos_a.distance_to(pos_b) > DISTANCIA_KILL:
        return
    _mortos[id_alvo] = true
    _aplicar_morte.rpc(id_alvo)
    _checar_vitoria()

Três checagens guardam o portão: o pedinte precisa ser impostor, ambos precisam estar vivos e a distância precisa caber no raio de kill. Como _posicao_de() lê a posição que o servidor mantém (e não um número que o cliente mandou junto), um impostor hackeado que tente matar do outro lado do mapa simplesmente não passa.

O corpo da vítima vira um cadáver no chão, que outro tripulante pode encontrar e usar para convocar a reunião. _aplicar_morte roda em todas as máquinas e faz o visual: esconde o personagem vivo, instancia o corpo, libera o modo fantasma para quem morreu.

Reunião de emergência e votação

A reunião é uma troca de fase. Qualquer jogador vivo que aperta o botão de emergência, ou que reporta um corpo, pede ao servidor para abrir a votação. O servidor pausa o movimento, teleporta todo mundo para a mesa e abre uma janela de tempo.

O ponto delicado da votação é o mesmo de sempre: o voto é secreto até a apuração. Então o cliente manda o voto só para o servidor, e o servidor guarda sem reenviar para ninguém até o tempo acabar:

var _votos: Dictionary = {}

@rpc("any_peer", "call_remote", "reliable")
func votar(id_alvo: int) -> void:
    if not multiplayer.is_server() or not _em_votacao:
        return
    var eleitor: int = multiplayer.get_remote_sender_id()
    if not _esta_vivo(eleitor) or _votos.has(eleitor):
        return
    _votos[eleitor] = id_alvo
    _confirmar_voto.rpc_id(eleitor)
    if _votos.size() >= _vivos_restantes():
        encerrar_votacao()

Cada eleitor vota uma vez (_votos.has(eleitor) bloqueia o segundo), precisa estar vivo e a resposta _confirmar_voto volta só para ele, apenas para a interface mostrar "voto registrado", sem revelar em quem. Quando todos os vivos votaram, ou o tempo estourou, o servidor apura:

func encerrar_votacao() -> void:
    _em_votacao = false
    var contagem: Dictionary = {}
    for alvo: int in _votos.values():
        contagem[alvo] = int(contagem.get(alvo, 0)) + 1
    var expulso: int = _mais_votado(contagem)
    if expulso != ID_PULAR:
        _mortos[expulso] = true
    _anunciar_resultado.rpc(expulso, _papel_por_peer.get(expulso, Papel.TRIPULANTE))
    _votos.clear()
    _checar_vitoria()

O _anunciar_resultado é o momento dramático: só agora, de uma vez, todo mundo vê quem foi expulso e se era impostor ou não. Um empate ou maioria no "pular" (ID_PULAR) não expulsa ninguém, e vale tratar esse caso explicitamente para a partida não travar.

Condição de vitória de cada lado

As duas pontas da partida têm condições opostas, e ambas são checadas só no servidor, sempre depois de uma morte, uma expulsão ou uma tarefa concluída:

func _checar_vitoria() -> void:
    if not multiplayer.is_server():
        return
    var impostores_vivos: int = _contar_vivos(Papel.IMPOSTOR)
    var tripulantes_vivos: int = _contar_vivos(Papel.TRIPULANTE)
    if impostores_vivos == 0:
        _fim_de_jogo.rpc(Papel.TRIPULANTE)
    elif impostores_vivos >= tripulantes_vivos:
        _fim_de_jogo.rpc(Papel.IMPOSTOR)
    elif _progresso_tarefas >= _total_tarefas:
        _fim_de_jogo.rpc(Papel.TRIPULANTE)

Tripulantes vencem de dois jeitos: expulsando todos os impostores ou completando todas as tarefas. Impostores vencem quando seu número iguala ou supera o de tripulantes vivos, porque a essa altura eles controlam qualquer votação. Chamar _checar_vitoria() em todo evento relevante garante que a partida termine no instante exato em que a condição acontece, sem depender de polling.

A camada de rede: ENet, @rpc e MultiplayerSpawner

Agora a parte que eu prometi tratar com honestidade. Tudo acima é lógica de jogo que roda tranquila. O que consome o grosso do tempo de um projeto desse é fazer essa lógica funcionar sincronizada entre máquinas, e aí mora a dificuldade real.

A fundação tem três peças da API high-level da Godot 4:

  • ENetMultiplayerPeer: cria o servidor e os clientes. O host faz create_server(porta, max_jogadores), os outros fazem create_client(ip, porta). É o transporte.
  • O anotador @rpc: marca quais funções podem ser chamadas de outra máquina, com os modos ("any_peer" ou "authority", "reliable" ou "unreliable", "call_local" ou "call_remote") que você viu ao longo do post.
  • MultiplayerSpawner: instancia os personagens dos jogadores em todas as máquinas quando alguém entra, mantendo a árvore de cena igual em todo mundo. Sem ele, você instancia jogador na mão e reza para os caminhos de node baterem, o que não escala.

Um esqueleto de conexão:

const PORTA: int = 8910

func hospedar() -> void:
    var socket: ENetMultiplayerPeer = ENetMultiplayerPeer.new()
    socket.create_server(PORTA, 10)
    multiplayer.multiplayer_peer = socket

func conectar(ip: String) -> void:
    var socket: ENetMultiplayerPeer = ENetMultiplayerPeer.new()
    socket.create_client(ip, PORTA)
    multiplayer.multiplayer_peer = socket

Por que isso é a parte mais difícil? Porque a posição dos personagens precisa chegar dezenas de vezes por segundo em todas as telas, sem engasgo e sem dar a impressão de que o outro jogador teleporta. Você vai usar um MultiplayerSynchronizer para replicar a posição e, cedo ou tarde, vai esbarrar em latência: o que você vê na sua tela está sempre alguns milissegundos atrasado em relação ao estado do servidor. Decidir kill, colisão e distância com base no estado autoritativo do servidor, e não no que a tela de cada um mostra, é o que impede que dois jogadores discordem sobre quem morreu. É um trabalho de depuração paciente, com duas ou mais janelas abertas lado a lado, e não tem atalho honesto.

Se você está decidindo o motor antes de começar e quer pesar as ferramentas de rede de cada um, a comparação em Godot vs Unity detalha o que cada engine oferece de multiplayer pronto.

Por onde começar sem se afogar

A tentação de montar tudo em rede desde o primeiro dia é o maior erro aqui. O caminho que funciona é em camadas:

  1. Faça a partida inteira rodar local, com jogadores controlados por teclado ou por bots simples, sem nenhuma RPC. Papéis, tarefas, kill, reunião, votação, vitória: tudo funcionando num processo só.
  2. Suba a conexão com ENetMultiplayerPeer e sincronize só o movimento com um MultiplayerSynchronizer. Teste com duas janelas até os personagens andarem suaves nas duas telas.
  3. Mova as ações decisivas (kill, tarefa, voto) para RPCs com validação no servidor, uma de cada vez, testando cada uma com duas instâncias abertas.

Testar sempre com pelo menos duas janelas (use o menu Debug da Godot 4 para rodar várias instâncias de uma vez) não é opcional. Um jogo de dedução social só existe de verdade quando há mais de uma tela, e a maioria dos bugs de sincronização só aparece com duas pessoas agindo ao mesmo tempo.

Um jogo tipo Among Us é um projeto honesto para subir de nível: a jogabilidade cabe numa semana, e o multiplayer vai te ensinar, na marra e para sempre, por que o servidor manda. Comece pequeno, mantenha o servidor como única fonte da verdade e teste em dobro. Até a próxima!

Perguntas frequentes

É difícil fazer um jogo tipo Among Us sozinho?

A parte de jogabilidade (andar, tarefas, reunião, votação) é tranquila para quem já fez um projeto na Godot. O que trava gente solo é o multiplayer sincronizado: fazer posição, papéis e votos baterem em todas as máquinas, sempre com o servidor como autoridade, é a parte mais difícil e mais demorada. Comece com a lógica rodando local e só depois leve para a rede.

Qual engine usar para um jogo de dedução social como o Among Us?

A Godot 4 é uma escolha sólida porque já traz uma API high-level de multiplayer (ENetMultiplayerPeer, o anotador @rpc e o MultiplayerSpawner) sem plugin pago. A Unity também serve, com Netcode for GameObjects ou Mirror. A decisão pesa mais no que você já domina do que no motor em si, mas para um projeto 2D pequeno a Godot entrega rápido.

Como os papéis de impostor e tripulante são sorteados?

O sorteio roda só no servidor, no começo da partida. Você embaralha a lista de peers conectados, marca os primeiros N como impostores conforme a configuração da sala e guarda o papel de cada um num Dictionary no servidor. Cada cliente recebe por RPC apenas o próprio papel, nunca a lista completa, senão qualquer um leria quem é o impostor na memória do jogo.

Preciso de servidor dedicado para um jogo tipo Among Us?

Não para começar. Um jogador pode ser o host, rodando servidor e cliente na mesma máquina, e os outros conectam pelo IP. Toda a validação (kill, voto, tarefa concluída) roda no processo do host. Servidor dedicado só vale a pena quando o jogo cresce, precisa de partidas públicas com matchmaking ou de uma autoridade neutra fora da máquina de um jogador.

Como evitar trapaça num jogo de impostor online?

A regra é uma: o cliente pede, o servidor decide. O cliente nunca mata, vota ou conclui tarefa direto; ele manda o pedido para o servidor, que checa distância, estado e papel antes de aplicar. Além disso, nunca envie a informação secreta (quem é impostor, quem votou em quem antes da hora) para quem não precisa dela, porque tudo que chega no cliente pode ser lido.