O Que Faz um Programador de Rede de Jogos: Netcode na Prática

O que faz um programador de rede de jogos (network programmer): latência, autoridade do servidor, sincronização, ferramentas e como entrar com portfólio.
O que faz um programador de rede de jogos, o network programmer, é garantir que duas ou mais pessoas em casas diferentes vejam o mesmo jogo ao mesmo tempo, ou pelo menos acreditem que estão vendo. A internet atrasa, perde pacote e entrega fora de ordem. O jogo precisa parecer instantâneo mesmo assim. Todo o trabalho desse profissional mora nesse intervalo entre o que a rede consegue entregar e o que o jogador sente na mão.
Trabalho com desenvolvimento há mais de 20 anos e multiplayer é a parte em que eu mais vejo projeto indie travar. O jogo funciona perfeito no computador do desenvolvedor e desmonta na primeira partida com um amigo em outra cidade. Este post faz parte da série sobre profissões da indústria. O panorama geral da área está no post sobre o que faz um programador de jogos; aqui o foco é só a especialização de rede: rotina, problemas que ela resolve, ferramentas, diferença para os cargos vizinhos e como entrar.
O que faz um programador de rede de jogos no dia a dia
A rotina varia com o tipo de jogo (um shooter competitivo e um jogo cooperativo por turnos têm exigências muito diferentes), mas o esqueleto se repete.
Define a arquitetura. Antes de qualquer linha, alguém decide: servidor dedicado, um jogador hospedando a partida, ou conexão direta entre todos? Quem tem a palavra final sobre a vida do inimigo, sobre a posição do jogador, sobre o item no chão? Essa decisão afeta custo de servidor, resistência a trapaça e a sensação de controle. Mudar depois é caro.
Transforma sistemas de gameplay em sistemas sincronizados. O programador de gameplay fez a porta que abre. O de rede pergunta: quem pode abrir, como os outros ficam sabendo, e o que acontece se dois jogadores apertarem o botão no mesmo quadro. Cada mecânica ganha uma camada a mais de perguntas.
Mede e corta banda. Cada byte enviado por segundo, multiplicado por jogadores e entidades na tela, vira conta de servidor e lag. Boa parte do trabalho é decidir o que precisa ir pela rede, com que frequência e com que precisão. A rotação de um barril decorativo não precisa ser enviada sessenta vezes por segundo.
Debuga o que só acontece com latência. O bug clássico de multiplayer não aparece rodando duas janelas no mesmo computador. Aparece com 150 milissegundos de atraso e 2% de perda de pacote. Por isso o network programmer passa muito tempo simulando conexão ruim de propósito.
Os problemas que o netcode resolve
Quem chega na área achando que é "mandar a posição do jogador pela internet" descobre rápido que essa é a parte fácil. Os problemas de verdade são estes.
Latência. Uma mensagem leva tempo para ir e voltar. Se o jogador aperta "andar" e espera a resposta do servidor para ver o personagem se mexer, o controle parece um carro sem direção. A solução comum é a predição no cliente: o jogo move o personagem na hora, localmente, e depois confere com o servidor. Se o servidor discordar, entra a reconciliação, que corrige a posição com o mínimo de solavanco possível.
Os outros jogadores na sua tela. As atualizações dos outros chegam em intervalos irregulares. Desenhar cada uma assim que chega faz os personagens teleportarem. A interpolação resolve mostrando os outros jogadores um pouquinho no passado, deslizando suavemente entre duas posições conhecidas.
Quem acertou quem. No shooter, você mirou e atirou na tela, mas na tela do servidor o alvo já tinha andado. A compensação de lag faz o servidor "voltar no tempo" para checar o acerto do ponto de vista de quem atirou. É uma das partes mais delicadas, porque o que é justo para quem atira pode parecer injusto para quem levou o tiro atrás da parede.
Trapaça. Regra de ouro do multiplayer: nunca confie no cliente. Se o cliente diz "peguei a moeda" e o servidor aceita sem conferir, alguém vai mandar "peguei mil moedas". Por isso jogos competitivos usam servidor autoritativo: o cliente pede, o servidor valida e decide.
Estado consistente. Dois jogadores pegam o mesmo item no mesmo instante. Só um pode ficar com ele, e os dois precisam concordar sobre quem. Parece detalhe e é a origem de boa parte dos bugs de item duplicado que você já viu em jogo grande.
O cliente pede, o servidor decide: um exemplo em Godot 4
Para tornar concreto, aqui vai o padrão mais básico de netcode com autoridade no servidor, usando o multiplayer de alto nível da Godot. O servidor abre a conexão com ENetMultiplayerPeer, o cliente pede para coletar uma moeda via RPC, e só o servidor decide se a coleta vale.
extends Node
const PORTA: int = 7000
const MAX_JOGADORES: int = 8
var moedas: Dictionary[int, Node3D] = {}
var pontos: Dictionary[int, int] = {}
func criar_servidor() -> void:
var peer: ENetMultiplayerPeer = ENetMultiplayerPeer.new()
var erro: Error = peer.create_server(PORTA, MAX_JOGADORES)
if erro != OK:
push_error("Falha ao abrir o servidor: %s" % error_string(erro))
return
multiplayer.multiplayer_peer = peer
func entrar(ip: String) -> void:
var peer: ENetMultiplayerPeer = ENetMultiplayerPeer.new()
peer.create_client(ip, PORTA)
multiplayer.multiplayer_peer = peer
print("Meu id na partida: ", multiplayer.get_unique_id())
## Chamado no cliente quando ele encosta numa moeda.
func tentar_coletar(id_moeda: int) -> void:
pedir_coleta.rpc_id(1, id_moeda)
## Roda no servidor (id 1). Qualquer jogador pode pedir.
@rpc("any_peer", "reliable")
func pedir_coleta(id_moeda: int) -> void:
if not multiplayer.is_server():
return
if not moedas.has(id_moeda):
return # ja foi coletada por outro jogador
var jogador: int = multiplayer.get_remote_sender_id()
pontos[jogador] = pontos.get(jogador, 0) + 1
remover_moeda.rpc(id_moeda)
## So o servidor pode mandar remover; roda em todo mundo, inclusive nele.
@rpc("authority", "call_local", "reliable")
func remover_moeda(id_moeda: int) -> void:
if moedas.has(id_moeda):
moedas[id_moeda].queue_free()
moedas.erase(id_moeda)
Repare no que o código faz e no que ele não faz. O cliente nunca soma ponto para si mesmo nem apaga a moeda por conta própria: ele só pede. O servidor confere se a moeda ainda existe (resolvendo o caso dos dois jogadores pegando ao mesmo tempo), registra quem pediu com get_remote_sender_id() e avisa todo mundo. Esse exemplo assume servidor dedicado; se o host também joga, a lógica de chamada muda um pouco. O passo a passo completo de conexão, autoridade e testes está no guia de multiplayer no Godot 4 com RPC.
Esse é o nível 1. O dia a dia de um network programmer profissional é pegar esse padrão e lidar com o que ele ainda não resolve: o atraso entre pedir e ver a moeda sumir, a sincronização de dezenas de jogadores em movimento, o servidor que precisa aguentar centenas de partidas.
Ferramentas e tecnologias
O conceito é o mesmo em qualquer engine. O que muda é a camada que você usa para chegar nele.
- Godot. Multiplayer de alto nível embutido:
ENetMultiplayerPeerpara a conexão, o anotador@rpcpara chamadas remotas,MultiplayerSpawnereMultiplayerSynchronizerpara replicar nós. Ótima para estudar, porque esconde pouco. - Unity. Netcode for GameObjects (solução oficial) e bibliotecas de terceiros muito usadas, como Mirror, Photon e Fish-Net.
- Unreal. Sistema de replicação próprio, maduro e muito usado em jogos competitivos.
- Plataformas e serviços. Steam Networking, Epic Online Services e serviços de relay e lobby. Saber integrar um deles é habilidade prática que aparece em vaga.
- Ferramentas de diagnóstico. Wireshark para inspecionar pacotes, simuladores de rede ruim (como o clumsy no Windows) para forçar latência e perda, e os profilers de rede das próprias engines.
Linguagem: C++ em estúdio grande e engine própria, C# no ecossistema Unity, GDScript ou C# na Godot. Mais importante que a linguagem é entender TCP e UDP, serialização de dados e o modelo cliente e servidor.
Diferença para os cargos vizinhos
Programador de gameplay. Cria a mecânica: o pulo, o tiro, a IA do inimigo. O de rede faz essa mecânica funcionar com várias pessoas ao mesmo tempo. Na prática a fronteira é fina e os dois trabalham colados. O post sobre o que faz um programador de gameplay detalha o lado de quem cria a mecânica.
Programador de backend e serviços online. Cuida do que existe fora da partida: login, inventário persistente, loja, ranking, matchmaking. Usa bancos de dados e APIs web, não sincronização a cada quadro.
Programador de engine. Em estúdio com engine própria, pode ser quem escreve a camada de rede de baixo nível (sockets, compressão, confiabilidade sobre UDP). O network programmer de gameplay usa essa camada para sincronizar o jogo.
Em estúdio indie, que é a maioria no Brasil, é comum uma pessoa só fazer gameplay e rede. Vaga com título exato de "network programmer" aparece mais em estúdio médio e grande com jogo online.
Como entrar na área com portfólio
Domine gameplay antes. Ninguém sincroniza bem um sistema que não sabe construir sozinho. Quase todo programador de rede começou fazendo mecânica single player.
Faça um jogo multiplayer pequeno e termine. Dois a quatro jogadores, uma mecânica, partida curta. Uma arena simples onde dois jogadores coletam moedas e se empurram ensina autoridade, sincronização e estado consistente de uma vez. Escopo pequeno é a diferença entre projeto entregue e projeto abandonado.
Teste com conexão ruim e documente. O diferencial do portfólio de rede é mostrar o problema e a solução. Grave o jogo com 200 milissegundos de latência simulada, antes e depois da interpolação. Escreva um texto curto explicando a arquitetura: quem é autoridade sobre o quê, quantos dados por segundo cada jogador envia, como você tratou a coleta simultânea. Recrutador técnico lê isso com atenção, porque prova raciocínio, não só resultado.
Prepare-se para o teste técnico. Em vaga de rede, é comum pedir para explicar predição, interpolação e autoridade, ou corrigir um bug de sincronização num projeto pronto.
É aqui que muita gente trava: sabe programar o jogo sozinho, mas não tem uma base sólida de engine para dar o passo seguinte, e o multiplayer vira uma pilha de gambiarra que ninguém consegue manter. Construir essa base com um jogo de ponta a ponta na Godot, entendendo nós, cenas, sinais e física antes de colocar a rede por cima, é exatamente o tipo de caminho que montamos aqui.
Vale a pena ser programador de rede de jogos?
Se você gosta de problema difícil e de entender por que as coisas dão errado, sim. É uma das especializações mais exigentes da programação de jogos, justamente porque mistura gameplay, desempenho e redes, e por isso tem menos gente preparada para ela. Jogo online, cooperativo e competitivo continuam sendo uma fatia grande do mercado, e quase todo projeto multiplayer precisa de alguém que entenda de verdade de autoridade e latência.
O caminho não começa no netcode. Começa sendo um bom programador de gameplay, fazendo um jogo multiplayer pequeno e terminado, e aprendendo a explicar as decisões que você tomou. Com isso no portfólio, a especialização vem com o tempo.
Perguntas frequentes
O que faz um programador de rede de jogos?
Ele faz o jogo multiplayer funcionar: decide quem tem autoridade sobre cada parte do estado, sincroniza o que cada jogador vê, esconde a latência da internet com técnicas como interpolação e predição, protege o jogo contra trapaça e mantém o uso de banda dentro do limite.
Network programmer e programador de backend são a mesma coisa?
Não. O programador de rede cuida da comunicação em tempo real durante a partida (posição, tiro, colisão, estado do mundo). O de backend cuida dos serviços em volta: contas, inventário salvo, loja, ranking, matchmaking. Em estúdio pequeno a mesma pessoa pode fazer as duas coisas, mas são problemas diferentes.
Preciso saber muito de redes de computadores para trabalhar com netcode?
Precisa do essencial: diferença entre TCP e UDP, o que é latência, perda de pacote e largura de banda, e o modelo cliente e servidor. Não precisa ser administrador de rede. O resto se aprende fazendo jogo multiplayer pequeno e vendo ele quebrar com latência simulada.
Dá para começar como programador de rede direto, sem experiência?
É raro. A maioria chega ao netcode depois de trabalhar com gameplay, porque sincronizar um sistema exige entender bem como ele funciona sozinho. O caminho realista é dominar gameplay, fazer projetos multiplayer pequenos no portfólio e se especializar aos poucos.
Qual engine é boa para estudar programação de rede de jogos?
A Godot é uma boa escolha para estudar porque o multiplayer de alto nível já vem embutido, com ENetMultiplayerPeer, o anotador @rpc e nós de sincronização. Unity e Unreal também têm soluções próprias. O conceito de autoridade, sincronização e latência é o mesmo em todas.


