Em um modelo de autoridade do servidor, o servidor é a única fonte de verdade para todo o estado do jogo, e os clientes são confiáveis apenas para relatar suas próprias entradas. Essa arquitetura é a base do código de rede de um jogo justo e competitivo, pois impede classes inteiras de trapaças, como flyhacks ou speedhacks, ao nunca confiar em um cliente para relatar sua própria posição ou estado.
Vantagens
Em um sistema ingênuo de propriedade do servidor, os clientes simplesmente enviariam suas entradas para o servidor e exibiriam os resultados do jogo enviados de volta pelo servidor. Embora tecnicamente correto, tal sistema enfrentaria uma latência de entrada significativa, pois cada ação do jogador teria que viajar até o servidor, ser processada e ter o resultado enviado de volta ao cliente antes de poder ser exibido. Para a maioria dos jogos, especialmente aqueles de ritmo acelerado, esse atraso de ida e volta faria com que a jogabilidade parecesse lenta, não responsiva e injogável.
No modelo de autoridade do servidor do Roblox, a latência é compensada fazendo com que os clientes prevejam instantaneamente os efeitos de suas entradas, além de enviá-las ao servidor. Por exemplo, quando um jogador pressiona uma tecla, o cliente não espera a resposta do servidor; em vez disso, ele prevê alguns quadros à frente do último estado conhecido do servidor. Isso permite que o cliente mostre o resultado da ação de entrada instantaneamente, efetivamente ocultando a latência da rede e fazendo o jogo parecer responsivo.
Às vezes, o cliente pode errar sua previsão (misprediction) e, devido à latência da rede, o cliente não saberá que cometeu um erro por alguns quadros. Por exemplo:
Quando uma previsão errada é detectada, o cliente deve corrigir sua previsão com base no estado autoritativo do servidor. Se o estado autoritativo for diferente do estado previsto pelo cliente, o cliente deve reverter e re-simular seus quadros previstos. Esse sistema de previsão do lado do cliente, reversão e re-simulação é conhecido como "compensação de latência" e ajuda a fazer jogos multiplayer autoritativos do servidor parecerem suaves e responsivos.
Configuração
O modelo de autoridade do servidor requer certas outras tecnologias do motor para funcionar corretamente. Confirme as seguintes configurações de propriedade no objeto Workspace no Explorer:
- Workspace.AuthorityMode deve ser Server (configurar isso automaticamente define os cinco seguintes).
- Workspace.NextGenerationReplication deve estar habilitado.
- Workspace.PlayerScriptsUseInputActionSystem deve estar habilitado.
- Workspace.SignalBehavior deve ser Deferred.
- Workspace.UseFixedSimulation deve estar habilitado.
- Workspace.StreamingEnabled deve estar habilitado.
Conceitos
O sistema de autoridade do servidor opera com alguns conceitos principais, conforme segue.
Previsão do cliente
Através da previsão do cliente, o cliente simula alguns quadros à frente do último estado conhecido do servidor para prever os efeitos das entradas do jogador imediatamente. Isso oculta a latência de entrada, mas a previsão pode mais tarde se revelar incorreta (misprediction do cliente) e, portanto, exigir correção. O cliente tenta simular apenas o suficiente à frente do último estado autoritativo conhecido do servidor para que suas entradas cheguem ao servidor no quadro pretendido. O número de quadros que o cliente preverá à frente do estado conhecido do servidor é baseado na latência entre o cliente e o servidor.
Misprediction do cliente
Quando o cliente recebe o estado autoritativo do servidor, ele verifica esse estado em relação a um registro histórico do que previu localmente para aquele quadro. Quando há uma diferença entre o que o cliente previu e o que o servidor realmente fez, isso é uma misprediction. As previsões erradas podem ocorrer por várias razões, incluindo mudanças na latência da rede, outros jogadores agindo de maneiras que o cliente não antecipou, a lógica do jogo sendo executada exclusivamente no servidor, etc.
Se o estado autoritativo for diferente do estado previsto pelo cliente, o cliente deve reverter e re-simular.
Reversão e re-simulação
Quando um cliente detecta uma misprediction, ele deve redefinir para o estado autoritativo do servidor e, em seguida, re-simular para voltar ao seu quadro previsto. Com base na latência da rede, o cliente tenta simular apenas o suficiente à frente do último estado autoritativo conhecido do servidor para que suas entradas cheguem ao servidor no quadro pretendido.
Em resumo, o cliente:
- Recebe o estado autoritativo do servidor e o compara com seu próprio estado previsto.
- Se a previsão do cliente estava incorreta:
- O cliente reverte para o último estado autoritativo conhecido recebido do servidor.
- O cliente re-simula do estado autoritativo para seu estado previsto, reaplicando quaisquer entradas locais.
Implementação
Propriedade de rede e previsão
No modelo de autoridade do servidor, você pode manter os objetos principais do jogo com propriedade do servidor sem incorrer no custo de latência de entrada normalmente associado à propriedade do servidor. Coisas como carros, personagens de jogadores ou outros objetos críticos para a jogabilidade podem permanecer com propriedade do servidor, mesmo ao interagir com outros jogadores.
Por padrão, o Roblox preverá automaticamente propriedades com acesso à simulação próximas ao jogador local Character, mas se você quiser um controle mais detalhado, pode forçar explicitamente a previsão de uma instância ativando ou desativando com RunService:SetPredictionMode().
A previsão automática se aplica a conjuntos de física inteiros, não a instâncias individuais. Quando o cliente prevê uma parte, ele também prevê cada parte que está fisicamente conectada a ela por meio de soldas, juntas ou restrições, junto com o pai Model dessas partes e qualquer Humanoid dentro desse modelo. Por exemplo:
- Um modelo de espada que está soldado a um personagem previsto se torna parte do conjunto do personagem, então é previsto automaticamente.
- Um modelo que está parentado ao personagem, mas não está fisicamente conectado a ele é um conjunto separado. Ele só é previsto se estiver dentro do raio de simulação do cliente ou se você forçar a previsão com RunService:SetPredictionMode().
Para verificar se uma instância específica está atualmente prevista, chame RunService:GetPredictionStatus() do cliente.
Sincronização de simulação
No modelo de autoridade do servidor, o cliente e o servidor devem ambos executar a simulação principal, e a simulação do cliente precisa ser capaz de reverter e re-simular quando ocorre uma misprediction. Para habilitar isso, escreva sua lógica principal dentro de funções vinculadas através de RunService:BindToSimulation() em um ModuleScript que é inicializado tanto no cliente quanto no servidor.

Durante uma re-simulação, o Roblox reexecutará as funções vinculadas à simulação via BindToSimulation(). Processar entradas de jogadores, interagir com objetos de física sincronizados e atualizar o estado principal do jogo deve ocorrer dentro dessas funções vinculadas.
Use time() para qualquer lógica baseada em tempo dentro de uma função de simulação vinculada, como dirigir a velocidade de uma animação ou oscilar um valor ao longo do tempo. Quando Workspace.AuthorityMode é Enum.AuthorityMode.Server, time() é sincronizado entre o cliente e o servidor e usa tempo de simulação de passo fixo. Durante a re-simulação, ele retrocede para o quadro autoritativo e avança à medida que o cliente reproduz quadros, então retorna um valor consistente cada vez que um quadro é simulado.
ModuleScript chamado Simulation em ReplicatedStorage:
local RunService = game:GetService("RunService")
local Players = game:GetService("Players")
local Simulation = {}
Simulation.Initialize = function()
RunService:BindToSimulation(function(deltaTime)
-- Ler entradas do jogador
-- Atualizar estado do jogo
end)
end
return SimulationSincronização de estado com atributos
O Roblox sincroniza automaticamente todas as propriedades com acesso à simulação em instâncias previstas. Para dados personalizados, atributos são a principal maneira de sincronizar instâncias marcadas como previstas; em tais instâncias, qualquer discrepância nos valores dos atributos entre a fonte de verdade do servidor e a previsão do cliente acionará uma reversão e re-simulação completa.
Limites de atributos
Para ser replicado, um atributo deve atender a todos os seguintes critérios:
- Ele está entre os primeiros 64 atributos em sua Instance.
- Seu nome contém no máximo 50 caracteres.
- Se um atributo do tipo string, seu valor contém no máximo 50 caracteres.
Acesso à simulação
Muitas propriedades e métodos na referência da API do motor incluem o rótulo Acesso à Simulação, por exemplo, BasePart.CFrame. Propriedades com esse rótulo serão previstas pelo sistema de autoridade do servidor. Além disso, apenas propriedades e métodos com esse rótulo podem ser acessados dentro de funções vinculadas com RunService:BindToSimulation().
Criar e remover instâncias
Dentro de funções vinculadas através de BindToSimulation(), você pode criar instâncias com Instance.new(), Instance:Clone(), ou Instance.fromExisting(). O cliente cria a instância imediatamente, e o Roblox a mescla com a cópia autoritativa do servidor quando essa cópia chega. Para detalhes, veja criação de instâncias preditivas.
Remover instâncias funciona de maneira diferente. Instance:Destroy() não tem acesso à simulação, e você não pode mudar o Parent de uma instância que já está no DataModel, então chamar qualquer um dentro de uma função vinculada causa um erro. Em vez disso, registre a intenção de remover uma instância em um atributo dentro da simulação, e depois remova a instância fora da simulação, como em uma conexão PostSimulation no servidor.
local RunService = game:GetService("RunService")
local character = script.Parent
RunService.PostSimulation:Connect(function()
-- "SwordEquipped" é escrito pela simulação quando o jogador desequipa a espada
local sword = character:FindFirstChild("Sword")
if sword and not character:GetAttribute("SwordEquipped") then
sword:Destroy()
end
end)Ações de entrada
Em um jogo autoritativo do servidor, a principal maneira de um cliente afetar o estado do jogo é através do Sistema de Ação de Entrada. Essas entradas são enviadas ao servidor e são reproduzidas durante a re-simulação no cliente. Como resultado, InputActions deve ser usado para todas as entradas que afetam a simulação principal e devem ser verificadas quanto à sanidade antes de serem processadas.
Observe que InputContexts deve ser um descendente de um Player para que o motor saiba quem tem a propriedade sobre o InputContext. Uma abordagem é adicionar seus InputContexts a uma pasta sob ReplicatedStorage e usar um Script sob ServerScriptService para clonar o InputContexts por jogador:

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local InputsFolder = ReplicatedStorage:WaitForChild("Inputs")
local function onPlayerAdded(player)
local clone = InputsFolder:Clone()
clone.Parent = player
end
Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
onPlayerAdded(player)
endUsando esse padrão, você pode ler InputActions para todos os jogadores em RunService:BindToSimulation() tanto no cliente quanto no servidor para receber os mesmos dados para um determinado quadro e registrar a entrada do quadro anterior em um atributo, por exemplo, para acionar uma corrida do personagem quando uma ação de entrada RunAction é acionada.
Eventos remotos
Eventos remotos ainda podem ser usados dentro do modelo de autoridade do servidor para facilitar a comunicação discreta entre cliente e servidor. Por exemplo, os servidores podem usar eventos remotos para transmitir dados sobre jogadores marcando pontos ou pegando objetos, e os clientes podem usar eventos remotos como uma API alternativa para enviar entradas ao servidor, como para pressionar botões ou tocar objetos no mundo 3D.
Animações
Animações que afetam a jogabilidade, como movimento de personagens ou animações de ataque, devem ser controladas dentro de funções vinculadas através de BindToSimulation() no mesmo ModuleScript que é executado tanto no cliente quanto no servidor. Membros principais de Animator e AnimationTrack, como LoadAnimation(), Play(), Stop(), AdjustSpeed(), e TimePosition têm acesso à simulação.
O estado da animação é parte da simulação prevista. Quando uma reversão ocorre durante uma animação, o cliente retrocede a animação para o estado autoritativo e a reproduz junto com o resto da simulação, para que as animações do cliente e do servidor permaneçam sincronizadas. Como o cliente pode substituir trilhas de animação durante uma reversão, não armazene referências de AnimationTrack entre quadros. Em vez disso, procure a trilha ao vivo a cada quadro com Animator:GetTrackByAnimationId(). Para um exemplo completo, veja escrevendo código de animação.
Sons e efeitos
Efeitos do lado do cliente, como sons e partículas, devem ser escritos sabendo que a simulação do cliente é apenas uma previsão do estado autoritativo do servidor. BindToSimulation() limita quais propriedades e métodos podem ser chamados de dentro de funções vinculadas para ajudar a guiá-lo a escrever apenas para o estado de simulação sincronizado. Exibir os resultados dessa simulação, acionar efeitos e sons, etc. deve ser feito em uma função separada conectada a RenderStepped que lê os resultados da simulação e aciona os efeitos desejados.
Como o cliente pode prever um evento que nunca acontece no servidor, seu código de renderização deve ser capaz de desfazer ou ocultar efeitos previstos incorretamente. Mais orientações sobre a renderização de uma simulação prevista são abordadas em tocando sons e efeitos visuais.
Projetos de exemplo
Além desta documentação, os seguintes modelos podem ajudá-lo a começar:


