Voltar para o Blog
Quest Log

Rollback netcode: o que é e quando usar

Dois lutadores em uma arena neon com linhas de previsão de movimento recalculando frames sobrepostos

Rollback netcode explicado sem enrolação: o que é, a diferença para delay-based, por que jogos de luta usam, o custo real e quando vale a pena no seu jogo.

Se você já jogou um jogo de luta online e sentiu que o golpe saía no mesmo instante em que apertava o botão, mesmo contra alguém do outro lado do país, você estava sentindo rollback netcode em ação. É a técnica de rede que virou padrão de qualidade no gênero e o motivo pelo qual comunidades inteiras reclamam quando um lançamento vem com rede "da velha escola". Mas rollback não é mágica nem uma caixa que você liga, é uma forma específica de organizar a simulação do seu jogo, com vantagens claras e um custo que nem todo projeto consegue pagar. Este guia explica o que é, como funciona por dentro, por que os jogos de luta abraçaram a ideia e, principalmente, quando vale a pena e quando é melhor nem tentar.

Antes de entrar no rollback, vale entender o problema que ele resolve. Em qualquer jogo online, o seu input e o do oponente precisam estar presentes nas duas máquinas para que a partida avance igual nos dois lados. O problema é que a informação leva tempo para viajar pela rede. Esse atraso é a latência (o famoso ping). A pergunta que todo netcode responde, de um jeito ou de outro, é simples: o que a sua máquina faz nos frames em que ela ainda não recebeu o input do outro jogador?

O caminho antigo: delay-based netcode

A resposta mais simples é esperar. Esse é o chamado delay-based netcode, que dominou os jogos de luta por décadas. A ideia é a seguinte: quando você aperta um botão, o jogo não executa o seu comando na hora. Ele adiciona um atraso proposital de alguns frames, manda o input para o oponente e só processa aquele frame quando tem certeza de que os dois lados têm todos os inputs daquele instante. Assim as duas máquinas avançam sempre em sincronia perfeita, frame a frame, sem nunca divergir.

O delay-based tem uma virtude enorme: é determinístico e barato. Como ninguém nunca executa um frame sem ter todos os inputs, nunca existe correção, nunca existe estado errado. A simulação é uma só, compartilhada e atrasada.

O preço aparece no controle. Esse atraso que o jogo adiciona é sentido pelos seus dedos. Com ping baixo o atraso é pequeno e tolerável. Quando o ping sobe, o jogo precisa adicionar mais frames de buffer para continuar sincronizado, e aí o controle começa a parecer "molenga", como se o personagem respondesse com um leve delay a tudo que você faz. Em um gênero onde um frame decide um combo, isso mata a experiência. Pior: se a conexão oscila, o jogo precisa travar e esperar os inputs atrasados, gerando aquele engasgo clássico da rede antiga.

A ideia central do rollback

O rollback parte de uma aposta ousada: em vez de esperar o input do oponente, o jogo assume que ele vai fazer a mesma coisa que fez no último frame conhecido e segue rodando a partida imediatamente. O seu input é processado na hora, sem atraso nenhum. O jogo prevê o input do oponente e avança como se a previsão fosse verdade.

Na maioria dos frames essa previsão acerta, porque em jogos rápidos os jogadores seguram direção e botões por vários frames seguidos. Quando o input real do oponente finalmente chega pela rede, o jogo compara com o que tinha previsto. Se bateu, ótimo, nada a fazer. Se não bateu, o jogo faz o rollback: ele volta para o último frame em que tinha certeza do estado, aplica o input correto do oponente e reexecuta todos os frames intermediários de uma vez, agora com a informação certa, até chegar de volta ao frame atual.

Esse ciclo acontece todo frame, muitas vezes por segundo, e o jogador nem percebe. O que ele percebe é um jogo que responde instantaneamente ao próprio comando. O custo visual, quando a previsão erra, é o oponente dar um pequeno teleporte de correção. Em jogos de luta bem feitos isso é tão sutil que passa despercebido na maioria das trocas.

A implementação de referência mais conhecida dessa ideia é a GGPO, uma biblioteca que popularizou o rollback nos jogos de luta e inspirou implementações próprias em vários estúdios e engines. Hoje é comum encontrar soluções de rollback integradas a engines e a middlewares, mas o conceito por trás é sempre o mesmo que você acabou de ler, independente da marca.

Como funciona por dentro, passo a passo

Para o rollback funcionar, o seu jogo precisa de três peças trabalhando juntas: um histórico de inputs, uma forma de salvar e restaurar o estado do jogo, e uma simulação que você consegue rodar manualmente, frame a frame. Veja o esqueleto da ideia em GDScript tipado, só para ilustrar o raciocínio:

extends Node

var frame: int = 0
var meus_inputs: Dictionary = {}
var inputs_oponente: Dictionary = {}
var ultimo_frame_confirmado: int = 0

func passo(input_local: int) -> void:
    meus_inputs[frame] = input_local
    var input_remoto: int = prever_input_oponente()
    avancar_simulacao(input_local, input_remoto)
    frame += 1

func prever_input_oponente() -> int:
    # na ausencia de dado novo, repete o ultimo input conhecido
    if inputs_oponente.has(frame - 1):
        return inputs_oponente[frame - 1]
    return 0

Quando o pacote de rede com o input real do oponente chega, para um frame que já foi simulado com previsão, entra a parte do rollback. O jogo precisa reconhecer que a previsão daquele frame pode estar errada, voltar ao estado salvo e reexecutar:

func ao_receber_input_remoto(frame_remoto: int, input_real: int) -> void:
    var previsto: int = inputs_oponente.get(frame_remoto, 0)
    inputs_oponente[frame_remoto] = input_real
    if input_real != previsto and frame_remoto < frame:
        rollback_para(frame_remoto)

func rollback_para(frame_alvo: int) -> void:
    restaurar_estado(frame_alvo)
    var atual: int = frame_alvo
    while atual < frame:
        avancar_simulacao(meus_inputs[atual], inputs_oponente.get(atual, 0))
        atual += 1

Repare no que esse código exige do resto do jogo. A função restaurar_estado precisa devolver a partida exatamente ao ponto que estava naquele frame: posição de cada personagem, barra de vida, timer de golpe, tudo. E avancar_simulacao precisa ser determinística, ou seja, dados os mesmos inputs e o mesmo estado inicial, ela tem que produzir sempre o mesmo resultado. Se houver qualquer aleatoriedade sem semente controlada, ou qualquer dependência do tempo real do sistema, a reexecução diverge e o rollback corrompe a partida em vez de corrigir.

Próximo nível
Quer aprender isso na prática?

No CursoGame.Dev você sai dos tutoriais soltos e constrói jogos publicáveis, com trilha progressiva, quests práticas e feedback real.

Conhecer a plataforma
+500 alunos4.9/5Garantia 7 dias

O custo real do rollback netcode

Aqui mora a parte que os tutoriais empolgados costumam esconder. O rollback impõe três exigências pesadas na arquitetura do seu jogo, e nenhuma delas é opcional.

A primeira é o determinismo. Toda a lógica de jogo precisa ser previsível e reprodutível. Isso significa cuidado redobrado com números de ponto flutuante (que podem variar sutilmente entre máquinas e plataformas), com geração de números aleatórios (que precisa usar uma semente sincronizada) e com qualquer sistema que você não controle, como física de engine ou plugins de terceiros que não foram feitos pensando nisso. Muitos estúdios de luta implementam a própria física simples em inteiros justamente para fugir desse problema.

A segunda é o estado serializável. Você precisa conseguir salvar o estado completo do jogo e restaurá-lo muito rápido, várias vezes por frame. Quanto mais coisa a sua partida guarda, mais caro fica salvar e restaurar. Isso empurra o design para um estado de jogo enxuto, bem separado da camada visual. O que é puramente cosmético (partículas, som, câmera) normalmente fica de fora do estado salvo, porque não afeta a lógica.

A terceira é o custo de reexecução. Quando o rollback acontece com um ping alto, o jogo pode precisar reexecutar vários frames de lógica dentro de um único quadro de renderização. Se a sua simulação de um frame é cara, multiplicar isso por oito ou dez em um frame só pode estourar o orçamento de processamento e derrubar o framerate justamente na hora da correção. Por isso o rollback combina tanto com jogos de lógica leve e poucos atores.

Quando vale a pena usar rollback

Rollback é a escolha certa quando o seu jogo é rápido, a resposta ao input é crítica e o número de jogadores é pequeno. Jogos de luta um contra um são o caso perfeito: dois atores, lógica relativamente contida, e uma comunidade que sente cada frame de atraso. Plataformas de ação competitiva, alguns jogos de arena e títulos retrô de reflexo também se beneficiam. A regra de ouro é: se o jogador percebe e odeia qualquer atraso entre o botão e a ação na tela, e o seu jogo é determinístico, o rollback justifica o trabalho.

Também vale quando você controla a simulação de ponta a ponta. Como o rollback exige determinismo e estado serializável, ele é bem mais fácil de aplicar em um projeto desenhado com isso em mente desde o começo do que enxertado em um jogo pronto. Se você está começando um jogo de luta agora, planejar a arquitetura em torno do rollback desde o primeiro dia é um investimento que se paga.

Quando NÃO vale a pena

Rollback é um péssimo encaixe para jogos com muitos jogadores. Reexecutar a simulação de dezenas de atores a cada correção é caro demais, e o volume de estado a salvar e restaurar explode. Um battle royale ou um MMO não rodam em rollback; eles usam outras abordagens, geralmente com servidor autoritativo e interpolação, onde um pouco de atraso visual é aceitável em troca de escala. Se você está nessa direção, entender a diferença entre multiplayer P2P e servidor dedicado importa mais do que rollback.

Também não vale para jogos de mundo grande, com física complexa de engine, ou que dependem de sistemas não determinísticos difíceis de domar. Forçar rollback nesses casos significa reescrever a física, abrir mão de recursos da engine e lutar contra o framework o tempo todo. O custo de engenharia some com o prazo do projeto. E para jogos mais lentos, por turnos ou cooperativos casuais, o atraso do delay-based simplesmente não incomoda, então toda essa complexidade seria esforço jogado fora.

Um bom roteiro de decisão é começar pela pergunta mais básica de arquitetura de rede antes de pensar em rollback. Se você ainda está montando a espinha do seu projeto online, vale ver primeiro como fazer um jogo multiplayer e depois estudar otimização de latência no netcode, porque rollback é uma técnica avançada que assume que você já domina o básico de sincronização e autoridade.

O resumo honesto

Rollback netcode troca a espera por previsão e correção. Em vez de segurar o seu input até o oponente responder, ele roda a partida na hora, chuta o que o outro vai fazer e volta no tempo para corrigir quando erra. Isso entrega a melhor sensação de resposta possível em jogos rápidos, e por isso virou padrão nos jogos de luta. O preço é alto: simulação determinística, estado serializável e lógica barata de reexecutar. Se o seu jogo é pequeno, rápido e você controla a simulação, rollback vale cada hora investida. Se é grande, cheio de atores ou dependente de física que você não controla, escolha outra abordagem e durma tranquilo. A técnica certa é sempre a que o seu jogo consegue pagar.

Perguntas frequentes

O que é rollback netcode em poucas palavras?

É uma técnica de rede em que o jogo nunca espera o input do oponente chegar. Ele prevê o que o outro jogador vai fazer, segue rodando a partida como se a previsão estivesse certa e, quando o input real chega, volta no tempo (rollback), corrige e reexecuta os frames afetados. O resultado é um jogo que responde na hora ao seu comando, mesmo com latência.

Qual a diferença entre rollback e delay-based netcode?

No delay-based o jogo segura o seu input por alguns frames esperando o input do oponente, para que as duas máquinas avancem sempre em sincronia. Isso adiciona atraso perceptível ao controle quando o ping sobe. O rollback não espera: ele prevê, segue em frente e corrige depois. O custo do delay é input lento; o custo do rollback é precisar reexecutar lógica e, às vezes, ver o oponente teleportar ao corrigir uma previsão errada.

Rollback netcode só serve para jogo de luta?

Não, mas é onde ele brilha mais. A técnica combina com jogos rápidos, determinísticos e de poucos jogadores, onde cada frame de atraso é sentido. Jogos de luta, plataformas de ação e alguns shooters arena se encaixam. Para jogos com muitos jogadores ou mundo grande, o custo de reexecutar tudo e de manter o estado serializável costuma inviabilizar.

O que preciso garantir no meu jogo para usar rollback?

Três coisas: simulação determinística (a mesma sequência de inputs sempre gera o mesmo resultado), estado de jogo que você consiga salvar e restaurar rápido, e lógica de jogo barata o suficiente para reexecutar vários frames em um quadro só. Se o seu jogo depende de float não determinístico, física de terceiros ou aleatoriedade sem semente controlada, rollback vira um pesadelo.