NetworkAnimator

Add NetworkAnimator to keep a Unity Animator in sync across workers and clients. Nebula sends parameter changes, triggers, and per-layer state while each copy continues running its local Animator.

If you are migrating from Unity Netcode for GameObjects (NGO), use the comparison table at the end of this page.

The component uses the sync channel and supports worker or owner authority.

Add the component to the GameObject with the Animator, or assign an Animator to its Animator field. Nebula logs an error during spawn when it cannot find one.

What is replicated

Keyframes (sent on a keyframe tick, on the first send after gaining authority, and in the spawn snapshot) carry all of the above, so a late joiner or a fresh ghost starts in the right state at the right playhead. See the keyframe section below for how playhead drift is handled.

Options

Turning SyncLayerStates, SyncLayerWeights and SyncTransitions all off removes the layer section from the chunk entirely; turning SyncParameters off removes the parameter section.

Triggers and authority

public void SetTrigger(string name);
public void SetTrigger(int hash);
public void ResetTrigger(string name);
public void ResetTrigger(int hash);

What SetTrigger does depends on who calls it:

The worker-side handler ignores the request if it is not authoritative for the entity or if the component is in owner mode (the owner should have fired it locally).

ResetTrigger is local only and is never replicated: a trigger that has already been sent has already been consumed on the remote copies. It also removes the hash from the pending list if it has not gone out yet.

public sealed class Pawn : NetworkBehaviour
{
    [SerializeField] private NetworkAnimator _anim;

    public override void NetworkTick(uint tick, float deltaTime)
    {
        _anim.Animator.SetFloat("Speed", Identity.Motion.Velocity.magnitude);
    }

    [ServerRpc]
    private void RpcAttack()
    {
        if (!HasAuthority) return;
        _anim.SetTrigger("Attack");
    }
}

Change detection

Once per tick, AuthorityTick compares each synchronized parameter and layer with its last recorded value. A partial update contains only changes and pending triggers. A keyframe contains every current value. Nebula clears the pending changes after sending them.

On a worker relaying an owner, the received chunk is applied and its parameter, trigger and layer entries are re-queued as dirty so they go out to everyone else.

Keyframes and late joiners

A keyframe carries every synchronised parameter and every layer. When one arrives at a non-authoritative copy:

• A parameter is set to the keyframe's value.
• A layer whose current state differs from the keyframe's (and that is not already transitioning to it) plays the keyframe's state from its normalized time.
• A layer already in the same state compares playback positions. If the difference exceeds NormalizedTimeResyncThreshold, the copy moves to the keyframe's normalized time. Smaller differences are left alone to avoid visible jumps.
• A transition in progress on the authority is started with CrossFadeInFixedTime on the copy if it is not already heading there.

Deltas apply the same rules without the playhead comparison (they only carry layers that changed).

The gateway caches the newest keyframe per behaviour index for every entity it knows and puts them in the spawn message it sends to a late joiner, so the joiner's Animator is in the right state before its first frame. A worker receiving a ghost or an authority transfer starts from the same snapshot.

Root motion on remotes

Enable DisableRootMotionOnRemote when remote copies receive their position from Nebula. The option disables applyRootMotion on those copies so animation does not also move them. Nebula restores the original value when a copy gains authority.

Disable this option when you want Nebula to leave applyRootMotion unchanged.

Delivery

NetworkAnimator is always reliable-ordered (SyncDelivery is Delivery.ReliableOrdered; there is no unreliable option). A lost trigger could never be recovered from a later keyframe because a trigger is an event, not a value. Its keyframes therefore go out only when the component is dirty on a keyframe tick. Unreliable child NetworkTransform components send periodic keyframes; root transforms use a separate stream with reliable recovery after movement.

Because the worker sends one sync message per delivery class per entity per tick, an animator and an unreliable transform on the same entity travel in separate packets; a reliable transform shares the animator's packet.

What is not replicated

• Trigger parameters set through Animator.SetTrigger directly.
• Parameters driven by animation curves (Animator.IsParameterControlledByCurve).
• Animator speed, IK, Animator.Play calls made outside a synchronised layer state (the resulting state change is picked up on the next tick if SyncLayerStates is on).
• Blend tree internals: only the parameters feeding them.

Compare with Netcode for GameObjects

Related