NetCrafter Relay Tutorial: Animated Multiplayer Character

Co-op syncs exactly one property per object: position. A fully-animated character needs six — position, rotation, and four Animator parameters (Speed, MotionSpeed, Grounded, Jump) — all replicating simultaneously on the same GameObject. Building this tutorial surfaced two real gaps in the sync system as it stood after Co-op, both now fixed:

1. SyncTarget had no Animator option at all. Before this tutorial, SyncRuleDefinition.syncTarget only covered Transform_Position/Rotation/Scale and Rigidbody_Velocity/AngularVelocity — nothing that could read or write an Animator parameter. Two new enum values now exist: Animator_Float and Animator_Bool, plus a new SyncRuleDefinition.animatorParameterName field (set in the Sync Settings tab) naming exactly which Animator Controller parameter each rule targets.

2. NetCrafterSyncManager could only register one binding per object, ever. This one was subtler and would have silently broken this exact tutorial: the binding registry used to be keyed by objectId alone (Dictionary<int, NetCrafterSyncBinding>). Co-op never noticed, because each capsule only ever carried one binding. The moment a single character carries six bindings under the same objectId — one for position, one for rotation, four for Animator parameters — each binding's registration would have silently overwritten the previous one, so only the last-registered rule would ever actually receive incoming data on remote clients. The registry is now keyed by (ruleName, objectId) together, so multiple bindings on one object coexist correctly. See API Reference for the updated signatures.

Nothing about this changes how you use NetCrafterSyncBinding day to day — Configure(id, hasAuthority) still works exactly the same way per binding. It just means an object with multiple bindings needs Configure() called on each of them, not once for the object as a whole (Part 7 below does this in a loop with GetComponents<NetCrafterSyncBinding>(), not by hand).

This part has nothing to do with networking yet — it gets Unity's Starter Assets Third Person character moving and animating locally, exactly as Unity ships it. Everything here is unchanged by the relay model; skip ahead to Part 2 if you already have a working single-player Starter Assets scene.

1.1 Install Cinemachine and Starter Assets

1. Window → Package Manager.
2. Switch the source dropdown to Unity Registry, search Cinemachine, select it, click Install. Do this before Starter Assets — the Starter Assets sample scene uses Cinemachine cameras and will show errors without it already present.
3. Starter Assets is not a Unity Registry package — it ships as a free Asset Store asset. Get it from the Unity Asset Store page for Starter Assets: Character Controllers | URP (or the older standalone Starter Assets - ThirdPerson | URP package): add it to your account from the web page, then in Unity's Package Manager switch the source dropdown to My Assets, find it in the list, and click Import.

When you first add a TextMeshPro component to a scene, Unity prompts you to import TMP Essentials — click Import TMP Essentials when this appears (if you haven't already, per the prerequisites above).

1.2 Import NetCrafter Relay

If you haven't already, import the NetCrafter Relay package into this project (Assets → Import Package → Custom Package…, or however you obtained it from the Asset Store). Confirm Assets/PivecLabs/NetCrafterRelay/ exists in the Project window afterward.

1.3 Open the sample scene and save a working copy

1. In the Project window, navigate to the imported Starter Assets sample scene (its exact path depends on which package variant you installed — look under a StarterAssets or ThirdPersonController/Scenes folder for a scene showing a character on a small platform/playground).
2. Open it, then File → Save As into Assets/Scenes/CharacterScene.unity. Work in this copy from now on — don't modify the original sample scene.

1.4 Confirm single-player works

1. Press Play.
2. WASD to move, mouse to look, Space to jump. Confirm walk/run/jump animations play and the Cinemachine camera follows correctly.
3. Press Stop.

The GameObject actually driving the character (Starter Assets typically names it PlayerArmature or similar — confirm the exact name in your imported version) has an Animator component whose Controller drives four parameters relevant to this tutorial: Speed (float), MotionSpeed (float), Grounded (bool), Jump (bool). Open the Animator window with this GameObject selected and confirm these four parameter names exactly — Part 6 depends on matching them exactly, character for character.

Tools → Pivec Labs → NetCrafter Relay. Click + Create Definition, enter CharacterDemo, click Create.

Open the Gameplay Messages tab. Click Create Gameplay Message three times.

3.1 Login — client tells the host its display name

Add one field: displayName (type string).

3.2 PlayerJoined — host announces a player (new or already-known) to someone

Add two fields: playerId (type int), displayName (type string).

3.3 PlayerLeft — host announces a player disconnected

Add one field: playerId (type int).

Same lesson as Co-op: there's no message here for position, rotation, or animation state at all. All six of those replicate continuously through the sync system (Part 6), not the schema/message system — the three messages above only ever fire once each, at login/join/leave.

Open the Host Actions tab. Create one.

4.1 HandleLogin

Custom Host Code (roster-replay pattern shared with the Co-op tutorial's HandleLogin — see there for the full explanation of why the replay loop exists — plus one line Co-op doesn't need, explained below):

string displayName = trigger.displayName;

foreach (var kv in CharacterGameState.PlayerNames)
{
    var existing = new PlayerJoinedEvent { playerId = kv.Key, displayName = kv.Value };
    connection.SendToPeer(senderId, "PlayerJoined", existing.Serialize(), true);
}

CharacterGameState.PlayerNames[senderId] = displayName;
var joined = new PlayerJoinedEvent { playerId = senderId, displayName = displayName };
connection.BroadcastToAll("PlayerJoined", joined.Serialize(), true);

// BroadcastToAll never loops back to the host's own incoming-message pipeline, so without
// this direct call the HOST never spawns a remote instance for a newly-joined player -- same
// "host can't rely on receiving its own broadcast" lesson as Co-op's RequestCollectPickup.
CharacterDemoController.Instance?.HostRegisterPlayerLocally(senderId, displayName);

4.2 The shared game-state helper

Assets/PivecLabs/Examples/CharacterDemo/Scripts/CharacterGameState.cs ships with the package — nothing to create here.

using System.Collections.Generic;

public static class CharacterGameState
{
    public static readonly Dictionary<int, string> PlayerNames = new();

    // Called from CharacterDemoController.Awake() -- static state survives across repeated
    // Unity Editor Play-mode sessions when Domain Reload is disabled.
    public static void Reset()
    {
        PlayerNames.Clear();
    }
}

Open Settings → Relay Settings and fill in your own coturn/rendezvous details (identical fields to the Chat and Co-op tutorials — Relay Host, Relay Port 3478, Rendezvous URL, Credential Mode StaticSecret, TURN Username, Shared Secret). Click Save Settings.

Open Build Code, click Validate Definition, then Generate All Files. This writes to Definitions/CharacterDemo/Generated/:

• Client/LoginRequest.cs, Client/PlayerJoinedEvent.cs, Client/PlayerLeftEvent.cs, Client/RelayConnectionManager.cs
• Host/HostActionRouter.cs
• Config/RelayConfig.json

Let Unity recompile and check the Console for CS0103: The name 'CharacterGameState' does not exist — if you see it, double-check Part 4.2's file exists.

Every rule below is a SyncRuleDefinition asset, created in Assets/PivecLabs/Examples/CharacterDemo/ via right-click → Create → PivecLabs → NetCrafterRelay → Sync Rule.

You'll assign these six rules to six NetCrafterSyncBinding components in Part 7 — one set on the local player, another matching set on the remote character prefab.

7.1 Add sync bindings to the local player

Select your character's root GameObject (PlayerArmature or equivalent, from Part 1.4) in CharacterScene. Six times: Add Component → NetCrafter → Sync Binding, then immediately drag one of Part 6's six rule assets onto that specific binding's Rule field before adding the next one (adding all six first and sorting out which rule goes where afterward is easy to mix up — do it one at a time).

Leave every added Sync Binding component's checkbox unchecked — CharacterDemoController (Part 7.5) enables all of them together, with the correct objectId/authority, right after login.

7.2 Build the remote character prefab

Step 1 — Duplicate, unpack, and strip. Right-click your local player GameObject in the Hierarchy → Duplicate. Rename the duplicate RemoteCharacterPrefab. Then, before touching any components: right-click RemoteCharacterPrefab → Prefab → Unpack Completely.

Remove these components (right-click each → Remove Component) — they all either read local input or drive physics that would fight directly-assigned sync data:

• Third Person Controller
• Basic Rigid Body Push
• Starter Assets Inputs
• Player Input

Leave the Character Controller and Animator components on — NetCrafterSyncBinding writing transform.position directly works fine alongside an enabled CharacterController; no manual disabling needed.

Step 2 — Add remaining components. Add Component → search for Remote Animation Event Receiver → add it. Starter Assets animation clips fire OnFootstep/OnLand SendMessage events that normally play sounds via ThirdPersonController, which you just removed; without a receiver, Unity logs a Console warning every time either event fires. RemoteAnimationEventReceiver.cs ships with the package (Assets/PivecLabs/Examples/CharacterDemo/Scripts/) — nothing to create, it's just a small stub that swallows both events:

using UnityEngine;

public class RemoteAnimationEventReceiver : MonoBehaviour
{
    // Empty on purpose -- Starter Assets' animation clips SendMessage these two event names
    // during footstep/landing frames. ThirdPersonController normally handles them (playing a
    // sound); it's removed from RemoteCharacterPrefab, so without these stubs Unity logs a
    // "SendMessage: no receiver" Console warning every time either animation event fires.
    public void OnFootstep(AnimationEvent animationEvent) { }
    public void OnLand(AnimationEvent animationEvent) { }
}

PlayerNameDisplay is added in Step 3 below, on NameCanvas — not here on RemoteCharacterPrefab itself. See the warning in Step 3 for exactly why that distinction matters.

The six NetCrafterSyncBinding components already exist on RemoteCharacterPrefab — they were duplicated along with everything else in Step 1, rules and all. Leave every one of them unchecked, same as the local player — CharacterDemoController configures and enables all six the moment this prefab is spawned for an actual remote player (Part 7.5).

Step 3 — Name tag canvas. Right-click RemoteCharacterPrefab → UI → Canvas. Name it NameCanvas.

• Canvas component: Render Mode → World Space.
• Transform: Position (0, 2.2, 0), Rotation (0, 0, 0), Scale (0.01, 0.01, 0.01) — the default Canvas scale is roughly 100× too large for world space; 0.01 brings it to the right size relative to the character.
• Rect Transform: Width 200, Height 50.

Right-click NameCanvas → UI → Text - TextMeshPro. Name it NameText. Anchor/stretch to fill the canvas (all offsets 0). On the TMP_Text component: Alignment Center/Middle, Font Size 36, Color white, leave the text itself empty (set at runtime).

With NameCanvas selected (not RemoteCharacterPrefab), Add Component → search for Player Name Display → add it. Drag NameText into its Name Text field. PlayerNameDisplay.cs ships with the package (Assets/PivecLabs/Examples/CharacterDemo/Scripts/) — nothing to create, for reference this is what it contains:

using UnityEngine;
using TMPro;

public class PlayerNameDisplay : MonoBehaviour
{
    public TMP_Text nameText;

    private Transform _cam;

    public void SetName(string displayName)
    {
        if (nameText != null) nameText.text = displayName;
    }

    private void LateUpdate()
    {
        if (_cam == null)
        {
            if (Camera.main == null) return;
            _cam = Camera.main.transform;
        }
        // Billboard -- face the tag toward whichever camera is currently active so it always
        // reads correctly regardless of which direction the character (and its Cinemachine
        // follow rig) is currently facing.
        transform.forward = transform.position - _cam.position;
    }
}

Step 4 — Save and remove from the Hierarchy. Drag RemoteCharacterPrefab from the Hierarchy into Assets/PivecLabs/Examples/CharacterDemo/Prefabs/RemoteCharacterPrefab.prefab, then delete it from the Hierarchy — it's now a prefab asset, spawned at runtime instead of pre-placed.

7.3 Build the UI

1. Canvas (Screen Space - Overlay) — name it UICanvas.
2. LoginPanel: TMP Text (Title, "Character Demo"), TMP Input Field (DisplayNameInput, placeholder "Enter your name..."), TMP Button (ContinueButton, "Continue").
3. LobbyPanel (unchecked by default): TMP Button (HostButton, "Host Game"), TMP Input Field (JoinCodeInput, placeholder "Join code..."), TMP Button (JoinButton, "Join Game"), TMP Text (JoinCodeDisplay, blank), TMP Text (StatusText, blank — shows connection errors/retry status; kept separate from JoinCodeDisplay so success and error text never share one field).
4. GameplayPanel (unchecked by default, Image alpha 0 — gameplay is the 3D scene behind it): TMP Text (ConnectedPlayersText, blank, anchored top-left) — a simple always-visible roster, separate from the floating name tags on remote characters themselves.

7.4 Create the RelayConnectionManager prefab and add the relay/event GameObjects

Open Scenes → Prefab Generator in the NetCrafter Relay window, confirm CharacterDemo is the selected schema, click Create RelayConnectionManager Prefab. This writes RelayConnectionManager.prefab to Definitions/CharacterDemo/Prefabs/ (a sibling of Generated/, not inside it — this prefab holds your actual relay settings once configured, so it's never touched by code regeneration) — do this before the Scene Assistant step below, so the connection-manager GameObject it adds to the scene comes from this prefab rather than a raw, disconnected GameObject. (Scene Assistant falls back to creating one either way if you skip this — nothing breaks — but building from the prefab is the intended path and keeps the scene object linked to a reusable asset.)

Open Scenes → Scene Assistant, confirm CharacterDemo is still the selected schema, confirm Add Event Dispatcher is checked, click Add to Existing Scene. This adds:

• RelayConnectionManager — an instance of the prefab you just created (CharacterDemo's generated connection type), added already disabled (same defensive reason as Chat/Co-op — see the warning in either tutorial if this is new to you).
• HostActionRouter — CharacterDemo's generated host-side logic dispatcher.
• NetCrafterEventDispatcher.
• NetCrafterSyncManager — added automatically because CharacterDemo has SyncRuleDefinition assets (Part 6).

Then: Settings → Scene Events → Add Router to Scene — creates a SceneEventRouter GameObject listing PlayerJoined and PlayerLeft, each with an empty On Received slot (wired in 7.5).

7.5 Attach and wire CharacterDemoController

Assets/PivecLabs/Examples/CharacterDemo/Scripts/CharacterDemoController.cs ships with the package:

using System.Collections;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
using TMPro;
using StarterAssets;
using PivecLabs.Generated.Character;
using PivecLabs.NetCrafterRelay;

public class CharacterDemoController : MonoBehaviour
{
    // Referenced by HandleLogin's Custom Host Code (see HostRegisterPlayerLocally below) --
    // the host process needs a way to call back into its own running scene, since
    // BroadcastToAll never loops back to the sender's own incoming-message pipeline.
    public static CharacterDemoController Instance { get; private set; }

    public GameObject relayConnectionManagerObject;

    public GameObject loginPanel;
    public TMP_InputField displayNameInput;

    public GameObject lobbyPanel;
    public TMP_InputField joinCodeInput;
    public TMP_Text joinCodeDisplay;
    public TMP_Text statusText; // optional -- errors/retry status on the Lobby panel

    public GameObject gameplayPanel;
    public TMP_Text connectedPlayersText;

    public GameObject localPlayerArmature;
    public GameObject remoteCharacterPrefab;

    private RelayConnectionManager relay;
    private string displayName = "Player";
    private NetCrafterSyncBinding[] _localBindings;
    private readonly Dictionary<int, GameObject> _remotePlayers = new();

    // Starter Assets' own cursor-lock handling (StarterAssetsInputs.OnApplicationFocus) locks
    // the cursor the moment the game window gains focus -- including on the very first frame,
    // long before ShowGameplay() ever runs -- which blocks clicking into displayNameInput/
    // joinCodeInput entirely (a locked cursor can't click a TMP_InputField). Cached here so
    // panel switches can drive the cursor explicitly instead of leaving it at that default.
    private StarterAssetsInputs _starterAssetsInputs;

    private void Awake()
    {
        Instance = this;
        CharacterGameState.Reset();

        relay = relayConnectionManagerObject.GetComponent<RelayConnectionManager>();
        relayConnectionManagerObject.SetActive(false);

        _localBindings = localPlayerArmature.GetComponents<NetCrafterSyncBinding>();
        _starterAssetsInputs = localPlayerArmature.GetComponent<StarterAssetsInputs>();

        ShowLogin();
    }

    private void Start()
    {
        NetCrafterEventDispatcher.Instance.Subscribe("RelayHosting", OnRelayHosting);
        NetCrafterEventDispatcher.Instance.Subscribe("ConnectionLost", OnConnectionLost);
        NetCrafterEventDispatcher.Instance.Subscribe("RelayStatus", OnRelayStatus);
    }

    // Confirmed live: StarterAssetsInputs has no Awake()/Start() of its own at all -- the only
    // place it ever applies Cursor.lockState is OnApplicationFocus, using whatever
    // cursorLocked happens to hold at that moment. That makes the cursor's actual state a
    // function of focus-change timing (alt-tab, clicking between two local test instances,
    // the very first frame entering Play Mode) rather than something the one-time
    // SetGameplayCursorLocked() calls below can fully guarantee on their own. Rather than
    // chase every individual race, this re-asserts the correct state every frame instead of
    // only at the three panel-transition points -- a stale lock (or a stale unlock) can never
    // persist past one frame, regardless of what reapplied it or when.
    private void Update()
    {
        bool shouldBeLocked = gameplayPanel != null && gameplayPanel.activeSelf;
        if (Cursor.visible == shouldBeLocked)
            SetGameplayCursorLocked(shouldBeLocked);
    }

    private void ShowLogin() { loginPanel.SetActive(true); lobbyPanel.SetActive(false); gameplayPanel.SetActive(false); SetGameplayCursorLocked(false); }
    private void ShowLobby() { loginPanel.SetActive(false); lobbyPanel.SetActive(true); gameplayPanel.SetActive(false); SetGameplayCursorLocked(false); }
    private void ShowGameplay() { loginPanel.SetActive(false); lobbyPanel.SetActive(false); gameplayPanel.SetActive(true); SetGameplayCursorLocked(true); }

    // Keeps the cursor free and visible (so displayNameInput/joinCodeInput can actually be
    // clicked into and typed in) while a UI panel is showing, and locked for Cinemachine's
    // camera-look controls once Gameplay actually starts. Also updates StarterAssetsInputs'
    // own cursorLocked/cursorInputForLook fields, not just Cursor.lockState directly -- those
    // fields are what OnApplicationFocus re-applies on the next focus change (e.g. alt-tab away
    // and back while still on the Login/Lobby panel); without updating them too, refocusing the
    // window would silently re-lock the cursor out from under an open panel.
    private void SetGameplayCursorLocked(bool locked)
    {
        Cursor.lockState = locked ? CursorLockMode.Locked : CursorLockMode.None;
        Cursor.visible = !locked;

        if (_starterAssetsInputs != null)
        {
            _starterAssetsInputs.cursorLocked = locked;
            _starterAssetsInputs.cursorInputForLook = locked;
        }
    }

    public void OnLoginClicked()
    {
        displayName = string.IsNullOrEmpty(displayNameInput.text) ? "Player" : displayNameInput.text;
        ShowLobby();
    }

    public void OnHostClicked()
    {
        if (statusText != null) statusText.text = ""; // clear any error/retry text from a previous attempt
        relayConnectionManagerObject.SetActive(true);
    }

    public void OnJoinClicked()
    {
        string code = joinCodeInput.text.Trim();
        if (string.IsNullOrEmpty(code)) return;
        if (statusText != null) statusText.text = "";
        relay.UpdateHost(code);
        relayConnectionManagerObject.SetActive(true);
        StartCoroutine(SendLoginWhenConnected());
    }

    private void OnRelayHosting(object joinCodeObj)
    {
        joinCodeDisplay.text = "Join code: " + (string)joinCodeObj;
        StartCoroutine(SendLoginWhenConnected());
    }

    private void OnConnectionLost(object reason)
    {
        Debug.Log("[CharacterDemo] Connection lost: " + reason);
        // Additive.
        if (statusText != null) statusText.text = NetCrafterConnectionStatus.ToPlayerMessage((string)reason);
    }

    // "RelayStatus" carries transient, already-friendly text (e.g. a retry-in-progress message)
    // rather than a raw reason string, so it's shown as-is instead of going through the mapper.
    private void OnRelayStatus(object message)
    {
        if (statusText != null) statusText.text = (string)message;
    }

    private const float HostLobbyDisplaySeconds = 4f;

    // Confirmed live: the rendezvous lookup alone can retry up to 3 times at 15s each on a slow
    // or flaky connection (RelayConnectionManager's RendezvousRequestTimeoutSeconds/
    // maxJoinAttempts) before TURN permissions and the hello/ack handshake even start -- a
    // real-network join can take well over 10 seconds without anything actually being wrong.
    private const float ConnectTimeoutSeconds = 60f;

    private IEnumerator SendLoginWhenConnected()
    {
        float deadline = Time.realtimeSinceStartup + ConnectTimeoutSeconds;
        while (!relay.IsConnected && Time.realtimeSinceStartup < deadline) yield return null;
        if (!relay.IsConnected) { Debug.LogError($"[CharacterDemo] Failed to connect within {ConnectTimeoutSeconds}s."); yield break; }

        if (relay.IsHost)
        {
            CharacterGameState.PlayerNames[relay.LocalUserId] = displayName;
            relay.OnPeerDisconnected += OnHostDetectedPeerDisconnected;
            yield return new WaitForSeconds(HostLobbyDisplaySeconds);
        }
        else
        {
            new LoginRequest { displayName = displayName }.Send(relay);
        }

        ConfigureLocalPlayer();
        RefreshPlayerList();
        ShowGameplay();
    }

    // Enables and configures all six sync bindings on the local player object -- one call
    // covers position, rotation, and all four Animator parameters, since Configure() means
    // the same thing on every one of them ("you're player N, and you drive this one").
    private void ConfigureLocalPlayer()
    {
        int myId = relay.LocalUserId;
        foreach (var binding in _localBindings)
        {
            binding.Configure(myId, true);
            binding.enabled = true;
        }
    }

    private void OnHostDetectedPeerDisconnected(int peerId)
    {
        var left = new PlayerLeftEvent { playerId = peerId };
        relay.BroadcastToAll("PlayerLeft", left.Serialize(), true);
        OnPlayerLeftReceived(peerId); // BroadcastToAll doesn't loop back to the host itself
    }

    public void OnPlayerJoinedReceived()
    {
        var ev = (PlayerJoinedEvent)NetCrafterSceneEventRouter.Instance.GetLastPayload("PlayerJoined");
        CharacterGameState.PlayerNames[ev.playerId] = ev.displayName;

        if (ev.playerId != relay.LocalUserId)
            SpawnOrUpdateRemote(ev.playerId, ev.displayName);

        RefreshPlayerList();
    }

    // Called directly from HandleLogin's Custom Host Code -- only on the process actually
    // hosting the session, and only for a player OTHER than the host itself (the host's own
    // login is registered directly in SendLoginWhenConnected's host branch above). Without
    // this direct call the host would never spawn a remote instance for its own joiners --
    // see Part 4.1's warning for what this looked like live before the fix.
    public void HostRegisterPlayerLocally(int playerId, string displayNameForPlayer)
    {
        CharacterGameState.PlayerNames[playerId] = displayNameForPlayer;
        if (playerId != relay.LocalUserId)
            SpawnOrUpdateRemote(playerId, displayNameForPlayer);
        RefreshPlayerList();
    }

    private void SpawnOrUpdateRemote(int playerId, string displayNameForRemote)
    {
        if (_remotePlayers.TryGetValue(playerId, out var existing))
        {
            existing.GetComponentInChildren<PlayerNameDisplay>()?.SetName(displayNameForRemote);
            return;
        }

        var instance = Instantiate(remoteCharacterPrefab);
        foreach (var binding in instance.GetComponents<NetCrafterSyncBinding>())
        {
            binding.Configure(playerId, false);
            binding.enabled = true;
        }
        instance.GetComponentInChildren<PlayerNameDisplay>()?.SetName(displayNameForRemote);
        _remotePlayers[playerId] = instance;
    }

    public void OnPlayerLeftReceived(int playerId)
    {
        CharacterGameState.PlayerNames.Remove(playerId);
        if (_remotePlayers.TryGetValue(playerId, out var instance))
        {
            Destroy(instance);
            _remotePlayers.Remove(playerId);
        }
        RefreshPlayerList();
    }

    public void OnPlayerLeftBroadcastReceived()
    {
        var ev = (PlayerLeftEvent)NetCrafterSceneEventRouter.Instance.GetLastPayload("PlayerLeft");
        OnPlayerLeftReceived(ev.playerId);
    }

    private void RefreshPlayerList()
    {
        var sb = new StringBuilder();
        foreach (var kv in CharacterGameState.PlayerNames)
            sb.AppendLine(kv.Value);
        if (connectedPlayersText != null) connectedPlayersText.text = sb.ToString();
    }
}

Create an empty GameObject named CharacterDemoController, drag the script onto it, and wire:

Wire the buttons and events:

• ContinueButton → On Click () → CharacterDemoController.OnLoginClicked()
• HostButton → On Click () → CharacterDemoController.OnHostClicked()
• JoinButton → On Click () → CharacterDemoController.OnJoinClicked()
• SceneEventRouter's PlayerJoined binding → On Received → CharacterDemoController.OnPlayerJoinedReceived()
• SceneEventRouter's PlayerLeft binding → On Received → CharacterDemoController.OnPlayerLeftBroadcastReceived()

1. Enable Run In Background (Edit → Project Settings → Player → Resolution and Presentation) so each Editor instance keeps its relay connection alive while unfocused.
2. Run one copy — the host. Click into the name field and type — the cursor should be a normal, free, visible cursor here, not locked/hidden (CharacterDemoController keeps it that way for as long as Login/Lobby is showing; see Part 7.5). Continue, Host Game. Move around with WASD, jump with Space — confirm your own animations still play locally exactly as in Part 1.4, and that the cursor is now locked for camera look (nothing about hosting changes your own local experience otherwise).
3. Run 2 more copies — joiners. Enter a name, Continue, type the join code, Join Game.
4. On every client, confirm:
   • Every other connected player's character appears with a floating name tag showing their display name.
   • Walking, running, and jumping on any one client's own character shows the correct animation — not just a moved position, the actual walk/run/jump animation state — on every other client's screen, in near-real time.
   • The ConnectedPlayersText panel lists every connected display name on every client.
5. Quit one joiner. After a short delay (host-side peer-timeout detection), that character should disappear (with its name tag) on every remaining client.

If avatars move but never animate on remote screens, or vice versa, see Common Mistakes below before assuming the network is broken.

If hosting or joining fails outright — relay unreachable, join code not found — StatusText on the Lobby panel now shows a plain-language message instead of a silent, unexplained Lobby screen (full detail still goes to the Console, unchanged). A join that's still retrying briefly shows "Retrying connection… (attempt N of 3)" first.

NetCrafter Relay — Pivec Labs