Editor de Gráfico de Animação

O Editor de Gráfico de Animação é uma ferramenta visual baseada em nós que capacita artistas técnicos e animadores a construir lógicas complexas de animação diretamente dentro do Roblox Studio. Ao fornecer uma interface simplificada para criar comportamentos como árvores de mistura, remove a dependência tradicional de scripts manuais para movimento de personagens.

Este sistema funciona em conjunto com seu fluxo de trabalho de animação existente:

• Editor de Animação: Continue usando o Editor de Animação como sua ferramenta principal para criar clipes individuais e ajustar keyframes e curvas.
• Editor de Gráfico de Animação: Use este novo espaço de trabalho para levar esses clipes e organizá-los em uma árvore lógica para impulsionar comportamentos de jogo sofisticados.

Projetado para melhorar a colaboração, o gráfico visual permite que os desenvolvedores inspecionem, depuram e compreendam rapidamente a lógica criada pelos animadores. Enquanto os artistas se concentram em refinar o movimento interativo, os desenvolvedores ainda podem acessar os nós do gráfico de animação programaticamente para controle direto sobre animações e estados mesclados.

Construir um gráfico

Para começar a construir lógica para um personagem animável, acesse o editor de gráfico de animação através da aba Avatar na faixa de opções do Studio. Os seguintes passos demonstram como inicializar um rig e construir uma rede de nós básica usando animações padrão de caminhada e aceno.

Para um mergulho mais profundo em aplicações práticas, você pode explorar o Arquivo de Referência do Gráfico de Animação, que contém exemplos de implementação tanto fundamentais quanto complexos.

Para criar seu próprio gráfico de animação, semelhante ao exemplo básico fornecido na referência, utilize os seguintes passos:

1. No Studio, adicione um rig animável navegando até a aba Avatar e selecionando Personagem ⟩ Meu Avatar.

   

2. Abra o Editor de Gráfico de Animação navegando até Editor de Gráfico na aba Avatar.

   

3. Selecione o rig animável na perspectiva 3D e selecione Criar Gráfico.

4. No Editor de Gráfico, clique com o botão direito e selecione Clipe.

   

5. No novo nó Clipe, defina o ID da Animação.

   1. Selecione o menu suspenso ID da Animação.

   2. Para enviar um ID de ativo de animação específico, clique em Importar.

      

   3. No campo ID da Animação, adicione a animação padrão Caminhar: 507777826.

   4. Selecione Importar.

6. Adicione outro nó de clipe repetindo os passos 4-5 usando a animação padrão Aceno: 507770239.

   

7. No Editor de Gráfico, clique com o botão direito e selecione Adicionar.

   

8. Conecte os nós de clipe ao nó Adicionar arrastando o conector de saída superior direito para a porta apropriada:

   1. Conecte o nó Clipe com a animação de caminhada à porta Base.
   2. Conecte o nó Clipe com a animação de aceno à porta Adicional.

   

9. A partir do nó Adicionar, conecte o conector de saída superior direito à porta de saída Pose do Gráfico.

   

10. (Opcional) Atribua um parâmetro à sua variável Velocidade.

    1. Clique e arraste a porta de Velocidade verde para uma área vazia. Um novo nó parâmetro será exibido.

       

    2. No canto superior esquerdo do editor de gráfico, use o painel de parâmetros para modificar rapidamente os parâmetros em seus nós. Você também pode acessar isso programaticamente.

       

11. Teste a animação pressionando o botão de reproduzir.

    

12. Tente testar vários pesos, velocidades, modos de reprodução e outras animações. Para mais informações sobre nós individuais, consulte a referência de nós.

Integração de API

Criar e implantar um Gráfico de Animação segue o padrão de pipeline de animação do Roblox. Após selecionar um rig no Editor de Gráfico de Animação, um novo ativo AnimationGraphDefinition é criado. Este ativo serve como o contêiner para seus nós, conexões e parâmetros. Uma vez que sua lógica esteja finalizada, você publica o gráfico para receber um ID de Ativo padrão.

Em seus scripts, você interage com esses gráficos carregando-os em um Animator como você faria com uma animação tradicional. Para conduzir a lógica interna do gráfico, use AnimationTrack:SetParameter() para passar valores em tempo real—como velocidade de movimento ou estados booleanos—diretamente nas variáveis do gráfico.

local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://123456789" -- Seu ID de Gráfico Publicado

local animationTrack = animator:LoadAnimation(animation)
animationTrack:Play()

-- Atualizações de parâmetros dinâmicos via RunService
game:GetService("RunService").Stepped:Connect(function(_, dt)
    local currentSpeed = humanoidRootPart.AssemblyLinearVelocity.Magnitude
    animationTrack:SetParameter("humanoidSpeed", currentSpeed)
end)

Referência de Nós

Cada nó de gráfico de animação serve como uma porta lógica ou fonte de dados que processa dados de animação antes de alcançarem o rig do personagem. Esta seção fornece uma descrição técnica dos blocos funcionais dentro do Editor de Gráfico de Animação. Todos os nós atualmente produzem uma pose de animação.

Cada seção de nó inclui:

• Definição – Um resumo do propósito e função do nó dentro do gráfico.
• Entradas – Os fluxos de dados que entram no nó. Múltiplas entradas são representadas como Input1, Input2, ..., InputN.
• Propriedades de entrada – Configurações ligadas diretamente a uma entrada específica (uma entrada Inativa atribuída a uma Posição de 0.5 em um nó Blend1D).
• Dados de Evento – Eventos emitidos ou consumidos pelo nó para disparar a lógica interna do gráfico ou scripts Luau externos. Esse comportamento pode mudar ao longo do desenvolvimento beta.

Regras de evento global

Para todos os nós e transições, as seguintes regras se aplicam por padrão:

• Os eventos se propagam para cima a partir de seu nó de origem através do gráfico. Cada evento carrega um peso representando a influência de sua origem na mistura final. Se o peso atingir zero em algum momento, o evento é silenciado.
• Nós sem lógica de evento personalizada passam todos os eventos sem alteração; nós que misturam ou selecionam entre entradas podem escalar o peso ou bloquear eventos de entradas não primárias (ver seção de Evento por nó).
• Eventos de marcador que alcançam o topo do gráfico podem ser observados via AnimationTrack:GetMarkerReachedSignal().

Clipe

Uma referência a um ativo AnimationClip. Este serve como um nó folheado no gráfico, gerando os dados brutos da animação que alimentam outros nós para mistura, seleção ou modificação.

Entradas

• Nenhuma

Propriedades

Propriedade	Tipo	Descrição
Clipe	ID do ativo	O ativo de animação a ser reproduzido (por exemplo, rbxassetid://12345).
Modo de Reproduzir	Enum.AnimationNodePlayMode	Define o comportamento do clipe uma vez que alcança o final de sua duração. Loop (padrão): Reinicia automaticamente a partir do início uma vez que o clipe termina. PingPong: Toca do início ao fim e, em seguida, imediatamente toca em reverso do fim ao início. Uma Vez e Segura: Toca uma vez e mantém a pose final ao concluir. Uma Vez e Reseta: Toca uma vez e retorna à pose inicial ao concluir.
Reverter	Booleano	Controla a direção da reprodução.
Velocidade	Número	Um multiplicador para a taxa de reprodução. 0.0 pausa o gráfico, 1.0 é velocidade normal, e 2.0 é o dobro da velocidade.
Truncar	Booleano	Alterna se a duração do clipe deve ser truncada.
TrimStart	Número	O timestamp absoluto (em segundos) onde a reprodução deve começar.
TrimEnd	Número	O timestamp absoluto (em segundos) onde a reprodução deve terminar.

Dados de Evento

• Manipulação de Eventos: Nenhuma. Este é um nó folheado sem filhos.
• Emissão de Eventos: Lê marcadores personalizados embutidos no clipe de animação (por exemplo, "Passo", "Swing da Arma") e os emite como eventos nomeados no exato quadro em que ocorrem. Se o clipe for truncado, apenas marcadores dentro do intervalo [TrimStart, TrimEnd] definido (inclusive) são emitidos.

Selecionar

Seleciona entre qualquer número de entradas via a propriedade Seleção. Sempre que a seleção atual muda, ela dispara uma nova transição.

Entradas

• Input1...InputN

Propriedades

Propriedade	Tipo	Descrição
Seleção	String	O ID único da entrada a ser selecionada, correspondendo ao nome da conexão de entrada (por exemplo, "Caminhar").

Dados de Evento

• Manipulação de Eventos: Eventos da entrada atualmente selecionada passam sem alteração em seu peso.
• Emissão de Eventos: Passa por todos os eventos da entrada atualmente selecionada apenas. Durante uma transição, a emissão de eventos segue as regras de eventos globais.

SeleçãoPrioritária

Avalia uma lista de entradas conectadas de cima para baixo e reproduz a primeira cuja condição avalia como verdadeira. Isso permite a seleção de animação hierárquica com base em lógica específica. Sempre que a seleção atual muda, ela dispara uma nova transição.

Entradas

• Input1...InputN

  • Trigger (Booleano): Uma condição lógica que deve ser verdadeira para que esta entrada se ative. Nas versões atuais, isso está ligado a um parâmetro booleano.
  • Interrompível (Enum.AnimationNodeInterruptible): Define a regra para quando esta animação ativa pode ser interrompida por uma entrada de maior prioridade.

    • Sempre (padrão): A entrada pode ser interrompida a qualquer momento por uma condição de maior prioridade.
    • Concluído: A animação atual deve completar sua reprodução antes que uma entrada de maior prioridade possa assumir.
    • Trigger: A entrada só é interrompível quando o InterruptibleTrigger está definido como verdadeiro.
  • InterruptibleTrigger (Booleano): Apenas disponível se Interruptible estiver definido como Trigger. A entrada pode ser interrompida quando essa expressão específica é verdadeira.

Propriedades

Propriedade	Tipo	Descrição
DefaultInterruptible	Enum.AnimationNodeInterruptible	A regra de interrupção base aplicada a todas as entradas. Cada entrada pode sobrescrever isso com sua própria propriedade de entrada Interruptible.
DefaultInterruptibleTrigger	Booleano	O valor de disparo base usado quando o modo Interruptible de uma entrada resolvida é Trigger. Cada entrada pode sobrescrever isso com sua própria propriedade de entrada InterruptibleTrigger.

Dados de Evento

• Manipulação de Eventos: Eventos da entrada atualmente selecionada passam sem alteração em seu peso.
• Emissão de Eventos: Passa por todos os eventos da entrada atualmente selecionada apenas. Durante uma transição, a emissão de eventos segue as regras de eventos globais.

Sequência

Ativa entradas conectadas em uma ordem sequencial específica com base em condições de espera definidas. Sempre que a seleção atual muda, ela dispara uma nova transição.

Entradas

• Input1...InputN

  • WaitFor (Enum.AnimationNodeWaitFor): Especifica a condição que deve ser atendida antes que a sequência avance para a próxima entrada.

    • Concluído (padrão): Avança para a próxima entrada quando a entrada atual completa um ciclo. O comportamento de avanço depende da entrada conectada:

      • Clipe de reprodução única: Avança quando o clipe termina.
      • Clipe em loop: Avança após um loop completo.
      • Sequência com loops infinitos: Avança após um ciclo completo através de todas as entradas.
      • Sequência com loops infinitos: Avança após a conclusão de todos os loops.
    • Trigger: Ativa a próxima entrada quando uma expressão lógica personalizada avalia como verdadeira.
  • WaitForTrigger (Booleano): Apenas disponível quando WaitFor está definido como Trigger.

Propriedades

Propriedade	Tipo	Descrição
LoopCount	Número	O número de vezes para percorrer a sequência completa (o padrão é 1). Um valor de 0 indica um loop infinito. Uma vez que a contagem é atingida, o nó respeita a configuração de loop ou retenção da última entrada.
DefaultWaitFor	Enum.AnimationNodeWaitFor	A condição de espera básica aplicada a todas as entradas. Cada entrada pode sobrescrever isso com sua própria propriedade de entrada WaitFor.

Dados de Evento

• Manipulação de Eventos: Eventos da entrada atualmente ativa passam sem alteração em seu peso.
• Emissão de Eventos: Passa por todos os eventos da entrada atualmente ativa na sequência apenas. Durante uma transição, a emissão de eventos segue as regras de eventos globais.

SequênciaAleatória

Seleciona e reproduz uma de suas entradas conectadas aleatoriamente. Quando a animação atualmente selecionada é concluída, o nó escolhe aleatoriamente outra entrada para reproduzir. Atribua a cada entrada um peso específico para influenciar a probabilidade de ser escolhida. Sempre que a seleção atual muda, ela dispara uma nova transição.

Entradas

• Input1...InputN

  • Peso (Número): Determina a probabilidade desta entrada ser selecionada; pesos mais altos aumentam a chance de seleção.

Propriedades

Propriedade	Tipo	Descrição
PlayCount	Número	O número de entradas que o nó irá tocar antes de parar. Uma vez alcançado, o nó respeita a configuração de loop ou retenção da última entrada. O padrão é 0 para infinito.
Seed	Número	Um valor usado para inicializar o Gerador de Números Aleatórios (RNG), garantindo que a sequência permaneça consistente em diferentes clientes. O padrão é -1 para semente aleatória.

Dados de Evento

• Manipulação de Eventos: Eventos da entrada atualmente ativa passam sem alteração em seu peso.
• Emissão de Eventos: Passa por todos os eventos da entrada atualmente ativa na sequência apenas. Durante uma transição, a emissão de eventos segue as regras de eventos globais.

Sobre

Sobrepõe a pose Sobre na pose Base. Quando combinada com um nó de Máscara, articulações mascaradas na pose Sobre revelam completamente a pose Base, criando um efeito de sobreposição transparente.

Entradas

• Base: A camada de fundo ou inferior, tipicamente uma animação de corpo inteiro como locomoção ou um estado ocioso.
• Sobre: A camada frontal ou superior a ser aplicada sobre a base, como um gesto com a mão ou animação de uso de ferramenta.

Propriedades

Propriedade	Tipo	Descrição
Peso	Número	O peso de mistura usado para atenuar a pose Sobre. O padrão é 1.0 (substituição completa) e é não clampado.

Dados de Evento

• Manipulação de Eventos:

  • O nó escuta eventos de ambas as entradas Base e Sobre.
• Emissão de Eventos:

  • Eventos de Base: Todos os eventos da entrada Base são passados sem modificação.
  • Eventos de Sobre: Eventos da entrada Sobre são escalados pela propriedade Peso.

    • Em Peso 0.5, eventos Sobre se propagam com peso reduzido.
    • Em Peso 0, eles são silenciados.

Adicionar

Adiciona a pose Aditiva à pose Base, atenuada por um Peso específico (não clampado).

Entradas

• Base: A pose de animação principal.
• Aditiva: A pose a ser sobreposta à base.

Propriedades

Propriedade	Tipo	Descrição
Peso	Número	Determina a força da pose aditiva aplicada à base.

Dados de Evento

• Manipulação de Eventos: O nó escuta eventos de ambas as entradas Base e Aditiva.
• Emissão de Eventos: Todos os eventos de entradas Base e Aditiva são passados sem modificação.

Subtrair

Converte uma animação em uma pose aditiva subtraindo uma pose base relativa da pose alvo ($A - B$). O resultado é atenuado por um Peso específico (não clampado).

Entradas

• A: A pose de animação alvo.
• B: A pose base relativa a ser subtraída.

Propriedades

Propriedade	Tipo	Descrição
Peso	Número	Determina a força do efeito de subtração aplicada ao resultado.

Dados de Evento

• Manipulação de Eventos: O nó escuta eventos de ambas as entradas Input A e Input B.
• Emissão de Eventos: Todos os eventos de ambas as entradas Input A e Input B são passados sem modificação.

Mesclar1D

Interpoe linearmente entre as duas poses de animação mais próximas à posição de entrada atual em um único eixo.

Entradas

• Input1...InputN

  • Posição (Número): A coordenada específica para cada entrada subsequente no eixo de mistura.

Propriedades

Propriedade	Tipo	Descrição
Posição	Número	O valor ativo atual no eixo de mistura usado para amostrar as animações. Se Posição estiver fora do intervalo das posições de entrada definidas, o nó extrapola usando as duas entradas mais próximas.
PhaseSync	Enum.AnimationNodePhaseSync	Configura se o tempo das entradas filhas deve ser sincronizado. Sincronizado (padrão): Sincronização normalizada. O nó calcula uma "duração virtual" com base na média ponderada das entradas ativas. Cada passo de tempo do nó de entrada é ajustado para que todas as filhas converjam para a mesma fase, mantendo animações de diferentes durações em sincronia. Não sincronizado: Mistura padrão onde clipes avançam independentemente em suas próprias taxas de reprodução.

Dados de Evento

• Manipulação de Eventos: O nó escuta eventos de todos os nós filhas atualmente ativos.
• Emissão de Eventos: Apenas eventos da entrada ativa com peso mais alto se propagam, escalados pelo seu peso de mistura. Eventos da entrada secundária são silenciados.

Mesclar2D

Mistura várias poses de animação com base em dois parâmetros de entrada dentro de um espaço de coordenadas 2D. Isso generaliza o nó Mesclar1D para lidar com cenários complexos, como misturar com base na direção e velocidade de movimento simultaneamente.

Entradas

• Input1...InputN

  • X (Número): A coordenada X para cada entrada subsequente.
  • Y (Número): A coordenada Y para cada entrada subsequente.

Propriedades

Propriedade	Tipo	Descrição
Modo de Entrada	Enum.AnimationNodeBlend2DInputMode	Define o sistema de coordenadas usado para avaliar o espaço de mistura: Cartesiano (padrão): Usa coordenadas padrão de grade 2D. X e Y representam a posição atual dentro do espaço de mistura. Polar: Usa valores angulares e de magnitude. X representa a direção em radianos, enquanto Y representa a magnitude ou força de movimento. A direção é ponderada mais pesadamente que a magnitude, então entradas em ângulos semelhantes, mas com magnitudes diferentes, se misturam mais suavemente do que entradas em ângulos diferentes.
X	Número	A coordenação X ativa atual (Cartesiana) ou Direção em radianos (Polar).
Y	Número	A coordenação Y ativa atual (Cartesiana) ou Magnitude (Polar).
PhaseSync	Enum.AnimationNodePhaseSync	Configura se o tempo das entradas filhas deve ser sincronizado. Sincronizado (padrão): Sincronização normalizada. O nó calcula uma "duração virtual" com base na média ponderada das entradas ativas. Cada passo de tempo do nó de entrada é ajustado para que todas as filhas converjam para a mesma fase, mantendo animações de diferentes durações em sincronia. Não sincronizado: Mistura padrão onde clipes avançam independentemente em suas próprias taxas de reprodução.

Dados de Evento

• Manipulação de Eventos: O nó escuta eventos de todos os nós filhas atualmente ativos.
• Emissão de Eventos: Apenas eventos da entrada ativa com peso mais alto se propagam, escalados pelo seu peso de mistura. Eventos da entrada secundária são silenciados.

Máscara

Aplica uma máscara predefinida à Pose de entrada. Uma máscara é definida por um peso por objeto (por exemplo, articulação) na hierarquia do rig, permitindo controle preciso ou "desvanecimento" da animação.

Entradas

• Pose: A pose de animação a ser mascarada.

Propriedades

Propriedade	Tipo	Descrição
Máscara	ObjectValue	Um ObjectValue (criado como um filho direto da definição do nodo de Máscara AnimationNodeDefinition) que define os pesos da máscara. Pode funcionar de uma das duas maneiras: Diretamente: O ObjectValue em si contém atributos mapeando nomes de objetos de rig para valores de peso específicos. Por Referência: O ObjectValue referencia outro Instance que contém os atributos de mapeamento. Isso permite máscaras compartilhadas entre diferentes nós no gráfico. Ao criar uma máscara, você pode escolher um esquema de rig (HumanoidRigDescription ou Picker) para preencher a hierarquia. HumanoidRigDescription: Padroniza a máscara para personagens humanoides. Picker: Permite ao usuário selecionar qualquer rig específico no espaço de trabalho para preencher a hierarquia da máscara.
Inverter	Booleano	Quando verdadeiro, aplica valores de peso como 1 - peso. Isso permite reutilizar uma máscara inversamente sem criar um novo ativo.

Dados de Evento

• Manipulação de Eventos: O nó escuta todos os eventos da entrada Pose.
• Emissão de Eventos: Todos os eventos da entrada Pose são passados sem modificação.

Velocidade

Modifica a taxa de reprodução de uma pose de animação de entrada.

Entradas

• Pose: A pose de animação ou subgráfico cuja velocidade de reprodução será modificada.

Propriedades

Propriedade	Tipo	Descrição
Velocidade	Número	Um multiplicador aplicado ao delta de tempo ($dt$). 0.0 pausa o gráfico, 1.0 é velocidade normal, e 2.0 é o dobro da velocidade.

Dados de Evento

• Manipulação de Eventos: O nó escuta eventos da entrada Pose.
• Emissão de Eventos: Todos os eventos da entrada Pose são passados sem modificação. Observe que enquanto a velocidade de reprodução visual muda, o tempo de eventos emitidos (como marcadores) será escalado de acordo com a taxa de reprodução modificada.

Saída do Gráfico

Representa a pose final avaliada do gráfico. Este nó é automaticamente incluído em todos os novos gráficos no Editor de Gráfico de Animação. Sua presença garante que o gráfico seja sempre válido e produza consistentemente uma pose de animação.

Entradas

• Pose: Os dados de animação processados finais a serem aplicados ao rig.

Propriedades

• Nenhuma

Dados de Evento

• Manipulação de Eventos: O nó escuta todos os eventos passados através da entrada conectada final.
• Emissão de Eventos: Este nó serve como o ponto de saída do pipeline de animação e não emite sinais de volta para o gráfico.

Transições

Vários nós no Gráfico de Animação (como Selecionar, Seleção Prioritária, Sequência e Sequência Aleatória) gerenciam como as animações se misturam ao alternar entre entradas ativas. Para evitar redundâncias na referência de nós, esses comportamentos são definidos por grupos de propriedades de transição padronizados.

Transição padrão

O comportamento de mistura básico aplicado ao nó sempre que muda para uma nova entrada ativa.

• DefaultTransitionDuration (número): O tempo (em segundos) que leva para misturar completamente na nova pose.
• DefaultTransitionCurve (Enum.PoseEasingStyle): A função de easing aplicada durante a mistura. Atualmente, suporta apenas Enum.PoseEasingStyle.Linear e Enum.PoseEasingStyle.CubicV2.

Sobrescrita de Transição

Propriedades de link específicas de entrada que superam a transição padrão. Estas são aplicadas quando o nó transita para essa entrada específica.

• TransitionOverrideDuration (número): Sobrescreve a duração de transição padrão.
• TransitionOverrideCurve (Enum.PoseEasingStyle): Sobrescreve a curva de transição padrão. Atualmente, suporta apenas Enum.PoseEasingStyle.Linear e Enum.PoseEasingStyle.CubicV2.

Replicação

Os parâmetros do gráfico de animação são locais para cada AnimationTrack e não são replicados automaticamente. Isso pode mudar em atualizações futuras, mas a abordagem atualmente recomendada utiliza:

• Cliente → Servidor: Um RemoteEvent para enviar parâmetros do cliente proprietário para o servidor a uma taxa fixa de tick.
• Servidor → Outros Clientes: Atributos de Instância que se replicam automaticamente para todos os clientes.

Personagens dos Jogadores

Um script do cliente dirige personagens de jogadores. Como apenas o cliente proprietário conhece o estado atual do jogo (entrada de movimento, estado do humanoide, etc.), os parâmetros devem fluir do cliente proprietário para o servidor e, em seguida, para todos os outros clientes.

Configuração

Sob StarterCharacterScripts, crie:

• Um LocalScript para animação do lado do cliente e condução de parâmetros.
• Um Script para replicação do lado do servidor.
• Um RemoteEvent para comunicação de cliente para servidor.

Script do Cliente

O cliente proprietário dirige os parâmetros de eventos de jogo e os envia ao servidor periodicamente. Outros clientes leem atributos replicados do script do servidor.

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local character = script.Parent
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:FindFirstChildOfClass("Animator") or humanoid

-- Carregue o gráfico de animação
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://YOUR_GRAPH_ID" -- Substitua com o ID do seu gráfico publicado
local track = animator:LoadAnimation(animation)
track:Play()

local isLocalCharacter = Players:GetPlayerFromCharacter(character) == Players.LocalPlayer

if not isLocalCharacter then
    -- Leia parâmetros replicados do script do servidor
    local animateServer = script.Parent:WaitForChild("AnimateServer")

    for attribute, value in animateServer:GetAttributes() do
        track:SetParameter(attribute, value)
    end

    animateServer.AttributeChanged:Connect(function(attribute)
        track:SetParameter(attribute, animateServer:GetAttribute(attribute))
    end)
    return
end

-- Jogador local: dirija parâmetros a partir dos eventos de jogo
local params = {}

local function setParam(key, value)
    track:SetParameter(key, value)
    params[key] = value
end

-- Exemplo: dirija parâmetros a partir do estado do humanoide
humanoid.Running:Connect(function(speed)
    setParam("Velocidade", speed)
    setParam("Estado", if speed < 0.1 then "Ocioso" else "Movendo")
end)

-- Envie parâmetros para o servidor a uma taxa fixa de tick
local replicateEvent = script.Parent:WaitForChild("ReplicateEvent")
local TICK_RATE = 1 / 20
local lastSendTime = 0

RunService.Stepped:Connect(function(gameTime)
    if gameTime - lastSendTime > TICK_RATE then
        lastSendTime = gameTime
        replicateEvent:FireServer(params)
    end
end)

Script do Servidor

Recebe parâmetros do cliente proprietário, dirige o gráfico de animação do lado do servidor e propaga valores como atributos para replicação a outros clientes.

local Players = game:GetService("Players")

local character = script.Parent
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:FindFirstChildOfClass("Animator") or humanoid

-- Carregue o mesmo gráfico de animação no servidor
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://YOUR_GRAPH_ID" -- Mesmo ID de gráfico que o cliente
animation.Parent = script
local track = animator:LoadAnimation(animation)
track:Play()

-- Receba parâmetros do cliente proprietário e replique via atributos
local replicateEvent = script.Parent:WaitForChild("ReplicateEvent")

replicateEvent.OnServerEvent:Connect(function(player, params)
    if Players:GetPlayerFromCharacter(character) ~= player then
        return
    end

    for key, value in params do
        track:SetParameter(key, value)
        script:SetAttribute(key, value)
    end
end)

NPCs

Como o servidor possui a animação de NPC, apenas a replicação de servidor para cliente é necessária. Dirija o gráfico de animação no servidor, escreva parâmetros como atributos em um Script do servidor e leia-os em clientes usando o mesmo padrão Instance.AttributeChanged mostrado acima.

Latência

Outros clientes veem animações com um pequeno atraso igual ao intervalo de tick (até 50 ms a 20 Hz) mais a latência da rede. Você pode reduzir o intervalo de tick aumentando a frequência (como 1/30), ao custo de maior tráfego de rede. 20 Hz é um padrão razoável; a mistura de animação é flexível o suficiente para que pequenos atrasos sejam difíceis de notar.