Como Fazer Jogo Multiplayer na Unreal: Replicação e RPCs

Como fazer jogo multiplayer na Unreal: replicação, servidor e cliente, Listen Server ou Dedicated, RPCs, variáveis replicadas, testes no editor e EOS.
Quem pesquisa como fazer jogo multiplayer na Unreal costuma esbarrar em duas reações opostas: "a Unreal já faz tudo sozinha" e "é complicado demais para indie". As duas estão erradas. A Unreal Engine tem um dos sistemas de rede mais maduros do mercado, herdado de anos de shooters online da própria Epic, mas ele só funciona bem quando você entende o modelo mental por trás: um servidor que manda, clientes que pedem, e a replicação levando o estado de um lado para o outro.
Este guia explica esse modelo na ordem em que você vai precisar dele: quem é servidor e quem é cliente, qual tipo de servidor escolher, como as variáveis e funções viajam pela rede, como testar tudo dentro do editor e onde entram o Online Subsystem e o Epic Online Services. Os nomes usados aqui são os da documentação oficial da Epic, para você conseguir buscar cada termo depois.
O modelo da Unreal: servidor autoritativo e clientes
A rede da Unreal é cliente-servidor. Sempre existe um servidor, e ele é a autoridade: é a cópia do jogo que decide o que é verdade. Os clientes rodam suas próprias cópias do mundo, mas essas cópias são reflexos do que o servidor diz. Se um cliente acha que acertou um tiro e o servidor discorda, vale o servidor.
Isso tem uma consequência direta no seu código ou Blueprint: toda lógica que importa (dano, pontuação, pegar item, abrir porta) precisa rodar no servidor. A função HasAuthority(), também disponível como nó Has Authority em Blueprint, responde exatamente essa pergunta: "esta cópia do ator é a autoritativa?". Em jogos com servidor, quem tem autoridade sobre os atores do mundo é o servidor.
Vale decorar onde cada classe do Gameplay Framework existe, porque metade dos bugs de iniciante vem daqui:
- GameMode: existe só no servidor. Regras da partida, spawn de jogadores, condição de vitória. Cliente nenhum enxerga o GameMode.
- GameState: existe no servidor e é replicado para todos. Bom lugar para placar, tempo de partida, fase do jogo.
- PlayerController: existe no servidor e no cliente dono daquele jogador. Os outros clientes não têm cópia dele.
- PlayerState: replicado para todos. Nome do jogador, pontos individuais, time.
- Pawn/Character: replicado para todos os clientes que precisam vê-lo.
Se você tentar ler o GameMode num cliente, vai receber nulo. Isso não é bug da engine, é o desenho do sistema.
Listen Server ou Dedicated Server
A primeira decisão de arquitetura é onde o servidor roda. A Unreal suporta os dois modelos clássicos, e a escolha muda custo, justiça e trabalho.
Listen Server: um dos jogadores é o servidor e joga ao mesmo tempo. É o modelo de muito jogo cooperativo indie: alguém cria a partida, os amigos entram. Você não paga hospedagem e o setup é simples. O custo é que o host joga com latência zero (vantagem em jogo competitivo), a upload dele limita a partida e, se ele fechar o jogo, todo mundo cai, a não ser que você implemente migração de host.
Dedicated Server: o servidor é um processo separado, sem renderização e sem jogador local, rodando numa máquina sua ou na nuvem. É o padrão de jogo competitivo, porque nenhum jogador tem vantagem e a partida não depende de ninguém ficar online. O preço: hospedagem mensal e mais trabalho de build. Para gerar o executável de servidor dedicado, a Epic orienta compilar a engine a partir do código-fonte (o acesso ao repositório vem pela vinculação da conta Epic ao GitHub), porque a versão instalada pelo launcher não gera esse target.
Para um primeiro projeto, Listen Server é o caminho sensato. O código que você escreve serve para os dois modelos, então migrar depois não é reescrever o jogo. Se quiser comparar os dois modelos com mais calma, incluindo peer-to-peer, o post sobre qual a melhor engine para jogo multiplayer coloca a Unreal lado a lado com as outras opções.
Replicação de atores e propriedades
Replicar é copiar estado do servidor para os clientes. Na Unreal, a replicação começa no ator: ele precisa estar marcado para replicar. Em C++, isso é bReplicates = true no construtor; em Blueprint, é a caixa Replicates no painel Class Defaults. Para movimento, a opção Replicate Movement sincroniza posição e rotação. O Character padrão já vem com o CharacterMovementComponent, que tem replicação e predição de movimento embutidas, e é por isso que o template de terceira pessoa funciona em multiplayer quase sem mexer.
Com o ator replicando, você escolhe quais variáveis acompanham. Em C++ a propriedade recebe o especificador Replicated dentro de UPROPERTY, e a classe registra essa propriedade na função GetLifetimeReplicatedProps com a macro DOREPLIFETIME. Em Blueprint, basta mudar o campo Replication da variável para Replicated.
Existe ainda a variação ReplicatedUsing (em Blueprint, RepNotify). Ela faz o cliente chamar uma função automaticamente quando o valor novo chega, uma função OnRep_ com o nome da variável. É o lugar certo para reagir visualmente: a vida mudou, atualize a barra; a porta abriu, toque a animação. Assim o servidor só altera o número e cada cliente cuida da própria tela.
Uma regra que evita dor de cabeça: replicação vai do servidor para os clientes, nunca o contrário. Se um cliente muda uma variável replicada localmente, a mudança fica só nele e é sobrescrita na próxima atualização do servidor. Para o cliente influenciar o jogo, ele precisa pedir. E pedir é trabalho das RPCs.
RPCs: Server, Client e NetMulticast
RPC (Remote Procedure Call) é uma função chamada numa máquina e executada em outra. A Unreal tem três tipos que você vai usar o tempo todo, definidos pelo especificador dentro de UFUNCTION:
- Server: chamada no cliente, executa no servidor. É o jeito do jogador pedir algo: "quero atirar", "quero abrir este baú". O servidor recebe, confere se faz sentido e aplica.
- Client: chamada no servidor, executa só no cliente dono daquele ator. Útil para avisos individuais: "você recebeu uma missão", "toque este som só para você".
- NetMulticast: chamada no servidor, executa no servidor e em todos os clientes conectados. Bom para efeitos que todo mundo precisa ver, como uma explosão.
Cada RPC também define a confiabilidade: Reliable garante entrega e ordem, Unreliable pode se perder. Segundo a documentação, RPCs são unreliable por padrão. Use Reliable para o que não pode falhar (o jogador apertou "pronto") e Unreliable para o que se repete muito e perde valor rápido (efeito cosmético a cada frame). Encher a rede de chamadas Reliable em alta frequência é receita para travar a conexão.
Para RPCs do tipo Server, existe o WithValidation, que adiciona uma função de validação: se ela retornar falso, o servidor descarta a chamada e desconecta o cliente. É uma camada simples contra cliente adulterado, por exemplo um pedido de dano maior do que a arma permite.
Um detalhe importante da documentação: uma RPC Server só sai do cliente se for chamada num ator que aquele cliente possui (tipicamente o próprio PlayerController, o Pawn que ele controla ou o PlayerState). Chamar Server RPC num ator do cenário que não é seu simplesmente não chega. O padrão comum é o jogador chamar a RPC no próprio Pawn, e o servidor, já com autoridade, mexer no ator do cenário.
Em Blueprint, RPCs são custom events. No painel de detalhes do evento, a seção Replicates oferece as opções de rodar no servidor, no cliente dono ou em multicast, e a caixa Reliable.
Como fazer jogo multiplayer na Unreal na prática: o fluxo de um tiro
Juntando as peças, o fluxo de uma ação multiplayer típica fica assim:
- O jogador aperta o botão de atirar. O input é lido no cliente, no Pawn ou no PlayerController dele.
- O cliente pode tocar já um efeito local (som, animação de recuo) para o controle parecer responsivo.
- O cliente chama uma RPC Server, por exemplo
ServerFire, passando a direção da mira. - No servidor, a função confere se o jogador pode atirar (munição, cooldown, está vivo), faz o traço de colisão e, se acertou, reduz a vida do alvo.
- A vida é uma variável replicada com RepNotify. Ela chega a todos os clientes, e a função
OnRep_atualiza a barra de vida e toca a reação de dano. - Se houver efeito que todos precisam ver e que não deriva de variável, como o clarão do disparo para os outros jogadores, entra uma NetMulticast unreliable.
Repare que o cliente nunca decide o dano. Ele pede, o servidor decide, a replicação conta para todos. Esse padrão serve para porta, item, habilidade e quase todo o resto.
Testando no editor com vários clients
Você não precisa de dois computadores para começar. No botão de Play do editor existe um menu de opções multiplayer:
- Number of Players: quantas janelas de jogo abrir.
- Net Mode: Play Standalone (sem rede), Play As Listen Server (a primeira janela é o servidor e as outras são clientes) ou Play As Client (o editor sobe um servidor dedicado em segundo plano e todas as janelas são clientes).
Teste sempre nos dois modos de rede. Um bug clássico é tudo funcionar no Listen Server, porque o host tem autoridade e roda a lógica localmente, e quebrar quando todos são clientes. Testar como Play As Client expõe esse tipo de erro cedo.
Rede local perfeita esconde problemas. Nas configurações do editor há emulação de rede, onde você adiciona latência e perda de pacotes artificiais. Ligue isso antes de achar que o jogo está pronto, porque é aí que aparecem os teletransportes e as ações que "não pegaram". O post sobre como fazer jogo multiplayer no Phaser mostra o mesmo problema visto de baixo, sem engine fazendo a replicação por você, e ajuda a entender o que a Unreal está resolvendo nos bastidores.
Online Subsystem e EOS: achar jogadores pela internet
Replicação resolve o jogo depois que todo mundo está conectado. Achar a partida, convidar amigo, ter conta e lobby é outro problema, e a Unreal o separa numa camada chamada Online Subsystem. Ela é uma interface comum com implementações diferentes por plataforma: OnlineSubsystemNull para testes em rede local, OnlineSubsystemSteam para Steam e OnlineSubsystemEOS para os Epic Online Services, entre outras. A ideia é que a lógica de sessão (criar, buscar, entrar) use a mesma interface e a plataforma seja trocada por configuração.
O EOS é a opção da própria Epic: gratuito, multiplataforma e com lobbies, matchmaking, P2P com relay, contas e conquistas. Para indie que não quer montar backend, costuma ser o caminho mais curto. As versões recentes da engine também trazem o plugin Online Services, uma geração mais nova dessa mesma camada; confira qual a documentação recomenda para a sua versão antes de começar. Se quiser entender custos, limites e quando o EOS compensa, o post sobre se o Epic Online Services vale a pena cobre isso em detalhe.
Erros comuns de quem começa multiplayer na Unreal
- Rodar lógica de jogo no cliente. Se o dano é calculado no cliente, o jogo dessincroniza e fica aberto a trapaça. Lógica que importa vai no servidor.
- Esquecer de marcar o ator como replicado. Variável replicada em ator que não replica não vai a lugar nenhum.
- Chamar Server RPC em ator que o cliente não possui. A chamada é descartada sem erro óbvio.
- Usar Reliable para tudo. Tráfego confiável em alta frequência entope a conexão.
- Testar só como Listen Server. O host esconde bugs que só aparecem quando todos são clientes.
- Escopo grande demais. Multiplayer multiplica o trabalho de cada sistema. Comece com dois jogadores numa arena pequena.
Por onde começar
Um roteiro realista: abra o template de terceira pessoa, rode com dois jogadores como Listen Server e veja o movimento já replicado. Depois adicione um item coletável que só o servidor pode destruir, uma variável de pontos replicada no PlayerState com RepNotify atualizando a interface, e uma RPC Server para a ação de coletar. Quando isso funcionar como Play As Client e com latência emulada, você entendeu o núcleo da rede da Unreal. Lobby, EOS e servidor dedicado vêm depois.
A Unreal é uma escolha forte para multiplayer, principalmente em 3D e em jogos de ação, mas é uma engine grande, com editor pesado e curva longa. Se o que você quer agora é aprender a fazer um jogo completo, do primeiro protótipo ao multiplayer, numa engine leve e gratuita que roda em qualquer máquina, a Godot tem um caminho mais curto até o jogo jogável, com replicação, RPCs e servidor dedicado nativos.
Os conceitos deste post (autoridade do servidor, replicação de estado, RPCs, confiabilidade) são os mesmos em qualquer engine. Aprender em uma deixa a próxima muito mais fácil.
Perguntas frequentes
A Unreal Engine tem multiplayer nativo?
Tem. A Unreal foi construída com rede desde a base: atores, variáveis e funções podem ser replicados entre servidor e clientes sem plugin extra. Você liga a replicação no ator, marca o que deve ser sincronizado e usa RPCs para mandar comandos. O que não vem pronto é o serviço online (matchmaking, contas, lobbies), que entra pelo Online Subsystem ou pelo EOS.
Dá para fazer multiplayer na Unreal só com Blueprint?
Dá. Atores têm a opção Replicates no painel de detalhes, variáveis podem ser marcadas como Replicated ou RepNotify, e custom events viram RPCs ao escolher o tipo de replicação na seção Replicates. C++ dá mais controle e desempenho, mas um protótipo multiplayer completo cabe em Blueprint.
Qual a diferença entre Listen Server e Dedicated Server na Unreal?
No Listen Server, um dos jogadores roda o servidor e joga ao mesmo tempo, então não há custo de hospedagem, mas o host tem latência zero e a partida cai se ele sair. No Dedicated Server, o servidor roda sem tela e sem jogador local, numa máquina sua ou alugada. É mais justo e estável, porém custa dinheiro e exige compilar a engine a partir do código-fonte para gerar o build de servidor.
Como testar multiplayer na Unreal sem outro computador?
No menu de Play do editor, aumente o Number of Players e escolha o Net Mode: Play As Listen Server ou Play As Client. O editor abre várias janelas, cada uma como um jogador conectado, e você vê a replicação acontecendo na hora. Para simular internet ruim, existem as configurações de emulação de rede no mesmo menu.


