NetCrafter Relay Tutorial: 2-4 Player Co-op Arena

Same transport model as Chat: every peer — host and joiners alike — opens one TURN allocation on your coturn relay and talks through it. Joiners cannot reach each other directly; every message routes through whichever player is hosting, and the host fans results out to everyone via BroadcastToAll.

Co-op adds two things on top of that:

Continuous position sync. Chat has no world state to keep in sync — a chat log is just a growing list of messages. Here, every player's avatar needs to visibly move on every other client's screen in real time. That's NetCrafterSyncBinding + NetCrafterSyncManager (covered in Part 6) — a small piece of the base package, separate from the schema/message system, that continuously replicates a Transform's position.

Host-authoritative scoring. Two players could walk onto the same pickup within the same network tick. If each client just locally decided "I touched it, +1 point" and told the host to broadcast that, a slow or lucky race could double-count a single pickup, or two different players could both get credit for it. Instead, every collection attempt — including the host's own — funnels through one piece of host-side logic (CoopGameState.TryCollectPickup, Part 3) that is the only place allowed to decide "has this pickup already been collected" and hands out credit exactly once. The host then broadcasts the outcome; nobody else's opinion about whether they collected something matters until the host confirms it.

1.1 Open the NetCrafter Relay window

Tools → Pivec Labs → NetCrafter Relay.

1.2 Create a new schema

Click + Create Definition, enter CoopDemo, click Create. This creates Assets/PivecLabs/NetCrafterRelay/Definitions/CoopDemo/ with all the standard subfolders and a fresh RelaySettings.asset with no working defaults, same as any new schema.

Open the Gameplay Messages tab. Click Create Gameplay Message five times and fill each in as follows.

2.1 Login — client tells the host its display name

Add one field: displayName (type string).

2.2 CollectPickup — client asks the host to credit a pickup

Add one field: pickupId (type int).

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

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

2.4 PickupCollected — host announces a pickup was credited

Add three fields: pickupId (type int), collectorPlayerId (type int), newScore (type int).

2.5 PlayerLeft — host announces a player disconnected

Add one field: playerId (type int).

Notice there's no message for position updates. Real-time movement doesn't go through the schema's message system at all — it uses a separate, always-on sync mechanism covered in Part 6. The five messages above are for discrete events (someone logged in, someone scored, someone left); continuous position is a different problem with a different, purpose-built solution.

Open the Host Actions tab. Create two.

3.1 HandleLogin

Custom Host Code:

string displayName = trigger.displayName;

// Tell the new joiner about every player already in the session -- PlayerJoined only ever
// fires once, at each player's own login, so without this replay a late joiner's local
// CoopGameState.PlayerNames would never learn earlier players' display names (scores stay
// correct either way, but their names would show a generic "PlayerN" fallback forever).
foreach (var kv in CoopGameState.PlayerNames)
{
    var existing = new PlayerJoinedEvent { playerId = kv.Key, displayName = kv.Value };
    connection.SendToPeer(senderId, "PlayerJoined", existing.Serialize(), true);
}

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

3.2 HandleCollectPickup

Custom Host Code:

if (CoopGameState.TryCollectPickup(trigger.pickupId, senderId, out int newScore))
{
    var result = new PickupCollectedEvent { pickupId = trigger.pickupId, collectorPlayerId = senderId, newScore = newScore };
    connection.BroadcastToAll("PickupCollected", result.Serialize(), true);
}

3.3 Add the shared game-state helper

Both Host Actions above reference CoopGameState, a small static helper that holds the two pieces of state a session needs: who's connected, and which pickups have been collected. Create it now — Assets/PivecLabs/Examples/CoopDemo/Scripts/CoopGameState.cs:

using System.Collections.Generic;

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

    private static readonly HashSet<int> _collectedPickups = new();
    private static readonly Dictionary<int, int> _scores = new();

    // Host-authoritative: the one place that decides "has this pickup already been collected"
    // and "what is this player's score now". Called from BOTH the generated HandleCollectPickup
    // host action (for a joiner's pickup) AND the scene controller's own host-branch (for the
    // host's own pickups). Having exactly one method mutate this state is what prevents
    // double-counting between those two call sites.
    public static bool TryCollectPickup(int pickupId, int playerId, out int newScore)
    {
        if (!_collectedPickups.Add(pickupId))
        {
            newScore = _scores.TryGetValue(playerId, out var existing) ? existing : 0;
            return false;
        }

        _scores.TryGetValue(playerId, out var current);
        newScore = current + 1;
        _scores[playerId] = newScore;
        return true;
    }

    // Called from CoopDemoController.Awake() -- static state survives across repeated Unity
    // Editor Play-mode sessions when Domain Reload is disabled, a common performance setting.
    // Standalone builds always start a fresh process, so this only matters for repeated
    // in-Editor testing.
    public static void Reset()
    {
        PlayerNames.Clear();
        _collectedPickups.Clear();
        _scores.Clear();
    }
}

This is a plain static class, not a MonoBehaviour — nothing to attach, nothing to drag in the Inspector. If you're building both the Chat and Co-op tutorials in the same project, notice this is named CoopGameState, not ChatPlayerRegistry — both examples' scripts compile into the same Assembly-CSharp assembly, so plain (non-namespaced) helper class names must not collide between them. This is the only place that collision risk actually exists in the whole project; the generated networking code itself never collides, because it's namespaced per schema.

You'll see CoopGameState referenced again later, in Part 7.8's CoopDemoController.cs — there's nothing further to do there either; by the time you reach it, this file already exists and that's the only place it's used besides the two Host Actions above.

Open Settings → Relay Settings. Every field is blank by default, same as Chat's — no working defaults, no Pivec Labs-run relay to fall back to.

If you haven't stood up coturn and the rendezvous service yet, see the Server Deployment Guide first.

Click Save Settings.

Open Build Code, click Validate Definition, then Generate All Files.

This writes to Definitions/CoopDemo/Generated/:

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

Let Unity recompile, then check the Console. If you see CS0103: The name 'CoopGameState' does not exist in the current context, double-check Part 3.3's file exists.

Before building the scene, here's the one genuinely new idea Co-op needs that Chat didn't.

The problem, concretely

In Part 7 you'll build 4 player capsules. If they only had ordinary Unity movement code on them (read WASD, move transform.position) and nothing else, here's exactly what would happen when you test it: press W on your own copy of the game, and your own capsule moves — but on every other connected copy, that same capsule just sits there, frozen. Moving transform.position only ever changes it on the one machine running that line of code; nothing about it tells any other machine anything happened. Multiply that by 4 players and everyone sees only themselves move.

Three small pieces (all part of the base package — none of them generated per-schema, none of them written by you) fix this:

• SyncRuleDefinition — a tiny asset that just answers "what do I sync, and how often?" For this tutorial: position, sent whenever it actually changes. You create exactly one of these in Part 7.6 and reuse it for all 4 capsules.
• NetCrafterSyncBinding — goes on each capsule. It's the part that actually sends (if this is your capsule) or receives (if it's someone else's).
• NetCrafterSyncManager — one per scene, needs no configuration. It's the switchboard that knows which incoming position update belongs to which capsule.

One more piece you'll wire (already written for you): the 4 capsules are pre-placed, not spawned per-player, so none of them know which network player they belong to until login finishes. NetCrafterSyncBinding.Configure(id, hasAuthority) is the one call that tells a capsule "you're player N, and it is/isn't you driving this one." CoopDemoController.cs calls it once per capsule right after login — you'll see this in Part 7.8, nothing extra to do.

Discrete events use the mechanism Chat already introduced

Login, pickups, and disconnects (the 5 messages from Part 2) aren't continuous like position — they're one-off announcements, and they go through the exact same event system Chat used: NetCrafterEventDispatcher (the low-level bus every event funnels through) and NetCrafterSceneEventRouter (the Inspector-friendly, no-code wrapper over it for schema events specifically). Both get added to the scene for you automatically in Part 7.8 — see the note there.

Every step below assumes an empty scene with nothing in it yet. This is a bigger scene than Chat's — an arena, 4 player avatars, 8 pickups, a hazard, and three UI panels — so it's broken into more sub-steps. Take them in order; several later steps assume earlier GameObjects already exist.

7.1 Camera and lighting

1. Select Main Camera. Set Transform → Position to (0, 16, -14) and Rotation to (48, 0, 0) — a fixed overhead-angled view of the whole arena, since there's no follow-cam in this tutorial.
2. On the Camera component, set Clear Flags to Solid Color and pick a dark background color (e.g. near-black).
3. Right-click in the Hierarchy → Light → Directional Light. Set Rotation to roughly (55, -30, 0) and Intensity to 1.1.

7.2 The arena

1. Right-click in the Hierarchy → Create Empty — name it Arena. Everything in this step is a child of it.
2. Right-click Arena → 3D Object → Cube — name it Ground. Set Position to (0, -0.5, 0) and Scale to (22, 1, 22). Give it a dark, desaturated material (Create → Material, drag onto the cube) — this is the floor players stand on.
3. Create four more cubes as walls, all children of Arena, each with a slightly lighter gray material than the ground:

7.3 Player avatar slots

You're building 4 pre-placed avatar slots, not spawning avatars dynamically — slot N gets assigned to whichever connected player has LocalUserId N (the host is always 0; joiners are 1 through 3 in join order), decided once, right after login, in Part 7.8's ConfigurePlayerSlots(). Every client independently computes the same assignment from the same rule, so no extra message is needed just to agree on who owns which slot.

1. Right-click in the Hierarchy → Create Empty — name it Players.
2. Four times, right-click Players → 3D Object → Capsule — name them PlayerSlot0 through PlayerSlot3.
3. Give each a distinct, bright material color (e.g. red, blue, green, yellow) so they're visually distinguishable — this matters for screenshots/GIFs of the finished demo, not just function.
4. Position them at the four corners, well clear of the walls:

5. On each slot, Add Component → Rigidbody. Check Is Kinematic, uncheck Use Gravity — movement here is script-driven position assignment, not physics-driven force, so a kinematic Rigidbody is what lets the capsule still register trigger events (pickups, the hazard) without physics pushing it around on its own.
6. On each slot, Add Component → search for Coop Player Controller (CoopPlayerController.cs, Part 7.7) → add it.
7. On each slot, Add Component → NetCrafter → Sync Binding. Leave every field at its default for now (you'll assign the rule in Part 7.6 and the id/authority at runtime via Configure()) — but uncheck the component itself (the checkbox next to "Sync Binding" in the Inspector, not the GameObject's own checkbox) to disable it. It gets re-enabled per-slot after login, in Part 7.8.

7.4 Pickups

1. Right-click in the Hierarchy → Create Empty — name it Pickups.
2. Eight times, right-click Pickups → 3D Object → Sphere — name them Pickup0 through Pickup7. Scale each to (0.6, 0.6, 0.6) and give them all the same bright yellow/gold material.
3. Position them at these eight points (a mix of cardinal and diagonal placements so no path through the arena avoids all of them):

4. On each pickup's Sphere Collider, check Is Trigger.
5. On each pickup, right-click the pickup itself → Effects → Particle System — name the child CollectEffect. On the Particle System component: uncheck Looping, set Duration to 0.6, Start Lifetime to 0.5, Start Speed to 3, and set Start Color to a warm yellow-white. This plays once when the pickup is collected, then the pickup (and eventually the particle GameObject itself) is destroyed/hidden — see CoopPickup.cs below.
6. On each pickup, Add Component → search for Coop Pickup (CoopPickup.cs, Part 7.7) → add it. Set Pickup Id to match the number in its name (Pickup0 → 0, Pickup1 → 1, etc. — these ids are what CollectPickupRequest/PickupCollectedEvent carry over the network, so they must be unique and must match what you wire in Part 7.8's pickups array order). Drag its own CollectEffect child's Particle System into Collect Effect.

7.5 Hazard

1. Right-click in the Hierarchy → 3D Object → Cube — name it Hazard. Position (0, 1, 0) (arena center), scale (2.5, 2, 2.5). Give it a distinct warning-red material.
2. On its Box Collider, check Is Trigger.
3. Add Component → search for Coop Hazard (CoopHazard.cs, Part 7.7) → add it.

7.6 Create the shared sync rule

1. In the Project window, navigate to Assets/PivecLabs/Examples/CoopDemo/ (create the folder if it doesn't exist yet).
2. Right-click → Create → PivecLabs → NetCrafterRelay → Sync Rule — name it PlayerPositionSyncRule.
3. In the Inspector, set Rule Name to PlayerPosition, Sync Target to Transform_Position, Sync Mode to OnChange.
4. Select all four PlayerSlot0–PlayerSlot3 GameObjects at once (Ctrl/Cmd-click each in the Hierarchy). With all four selected, drag PlayerPositionSyncRule onto the Rule field of the Sync Binding component in the Inspector — multi-object editing applies it to all four at once.

7.7 Add the gameplay scripts

Three scripts ship with the package (alongside CoopGameState.cs from Part 3.3) — you don't write these from scratch, just attach them. All three already got attached to their respective GameObjects in the steps above; this section is for reference on what they do.

Assets/PivecLabs/Examples/CoopDemo/Scripts/CoopPlayerController.cs — already attached in Part 7.3, shown here for reference only:

using UnityEngine;
using UnityEngine.InputSystem;

public class CoopPlayerController : MonoBehaviour
{
    public float moveSpeed = 5f;
    public bool HasAuthority { get; private set; }
    public int PlayerId { get; private set; }

    private Vector3 _spawnPoint;

    private void Awake()
    {
        _spawnPoint = transform.position;
    }

    // Called by CoopDemoController once the local player's id is known (after login) --
    // slots this avatar to a specific network player id and decides whether THIS client
    // drives it (true) or only receives its position via sync (false).
    public void Configure(int playerId, bool hasAuthority)
    {
        PlayerId = playerId;
        HasAuthority = hasAuthority;
    }

    private void Update()
    {
        if (!HasAuthority) return;
        if (Keyboard.current == null) return;

        Vector3 move = Vector3.zero;
        if (Keyboard.current.wKey.isPressed) move += Vector3.forward;
        if (Keyboard.current.sKey.isPressed) move += Vector3.back;
        if (Keyboard.current.aKey.isPressed) move += Vector3.left;
        if (Keyboard.current.dKey.isPressed) move += Vector3.right;

        if (move != Vector3.zero)
            transform.position += move.normalized * moveSpeed * Time.deltaTime;
    }

    // Called by CoopHazard's trigger. Purely local -- no networking needed here at all,
    // since the position change rides on this player's own already-continuous
    // NetCrafterSyncBinding updates, which every other client is already receiving.
    public void ResetToSpawn()
    {
        transform.position = _spawnPoint;
    }
}

Assets/PivecLabs/Examples/CoopDemo/Scripts/CoopPickup.cs — already attached in Part 7.4, shown here for reference only:

using UnityEngine;

public class CoopPickup : MonoBehaviour
{
    public int pickupId;
    public ParticleSystem collectEffect;

    private bool _collected;

    private void OnTriggerEnter(Collider other)
    {
        if (_collected) return;

        var player = other.GetComponent<CoopPlayerController>();
        if (player == null || !player.HasAuthority) return;

        // Optimistic local hide for responsiveness -- the authoritative PickupCollected
        // broadcast (below, via MarkCollected) is still what makes this permanent and what
        // every OTHER client actually relies on. Host-authoritative validation
        // (CoopGameState.TryCollectPickup) is the real dedup guard, not this flag.
        HideLocally();
        CoopDemoController.Instance.RequestCollectPickup(pickupId);
    }

    private void HideLocally()
    {
        _collected = true;
        if (collectEffect != null)
        {
            collectEffect.transform.SetParent(null, true);
            collectEffect.Play();
            Object.Destroy(collectEffect.gameObject, 2f);
        }
        gameObject.SetActive(false);
    }

    // Called on every client (including the collector, redundantly) when the
    // PickupCollected broadcast for this pickup arrives -- the actual authoritative signal.
    public void MarkCollected()
    {
        if (_collected) return;
        HideLocally();
    }
}

Assets/PivecLabs/Examples/CoopDemo/Scripts/CoopHazard.cs — already attached in Part 7.5, shown here for reference only:

using UnityEngine;

public class CoopHazard : MonoBehaviour
{
    public float rotateSpeed = 60f;

    private void Update()
    {
        transform.Rotate(Vector3.up, rotateSpeed * Time.deltaTime);
    }

    private void OnTriggerEnter(Collider other)
    {
        var player = other.GetComponent<CoopPlayerController>();
        if (player != null && player.HasAuthority)
            player.ResetToSpawn();
    }
}

7.8 Build the UI and add the relay/event GameObjects

1. Create a Canvas (right-click Hierarchy → UI → Canvas), confirming Render Mode is Screen Space - Overlay.
2. Login panel: right-click Canvas → UI → Panel — name it LoginPanel. Add a Text - TextMeshPro child (Title, text Co-op Arena Login), an Input Field - TextMeshPro child (DisplayNameInput, placeholder Enter your name...), and a Button - TextMeshPro child (ContinueButton, label Continue).
3. Lobby panel: right-click Canvas → UI → Panel — name it LobbyPanel. Add a Button - TextMeshPro (HostButton, label Host Game), an Input Field - TextMeshPro (JoinCodeInput, placeholder Join code...), a Button - TextMeshPro (JoinButton, label Join Game), a Text - TextMeshPro (JoinCodeDisplay, blank text — filled in at runtime), and a Text - TextMeshPro (StatusText, blank text — shows connection errors/retry status; kept separate from JoinCodeDisplay so success and error text never share one field). Uncheck LobbyPanel to disable it — you start on Login.
4. Gameplay panel: right-click Canvas → UI → Panel — name it GameplayPanel. Set its Image component's alpha to 0 (gameplay is the 3D arena behind it, not a dark overlay). Add a Text - TextMeshPro child (ScoreboardText, blank text, anchored top-left) for the live scoreboard. Uncheck GameplayPanel to disable it.
5. Relay/event GameObjects — added automatically, not built by hand: open Scenes → Scene Assistant in the NetCrafter Relay window (make sure CoopDemo is still the selected schema). Confirm Add Event Dispatcher is checked (it is by default), then click Add to Existing Scene. In one click, this adds:
   • RelayConnectionManager — this schema's own generated connection type, found automatically by looking specifically inside CoopDemo's generated output (not a generic name search), so there's no way for it to end up wired to a different schema's type by mistake. Created already disabled — see the warning below for why that matters.
   • HostActionRouter — this schema's generated host-side logic dispatcher.
   • NetCrafterEventDispatcher — since the toggle was checked.
   • NetCrafterSyncManager — added automatically because CoopDemo has a SyncRuleDefinition (the one from Part 7.6); a schema with no sync rules at all wouldn't get one.
   None of these four need any further setup — no Add Component, no manually unchecking a box, nothing to drag onto them.
6. Settings → Scene Events → Add Router to Scene — creates a SceneEventRouter GameObject listing PlayerJoined, PickupCollected, and PlayerLeft, each with an empty On Received slot (wired in step 9, after the controller exists).

7. Attach CoopDemoController.cs (ships with the package, at Assets/PivecLabs/Examples/CoopDemo/Scripts/CoopDemoController.cs): Create Empty at the Hierarchy root — name it CoopDemoController — drag the script onto it.
8. Wire its Inspector fields:

9. Wire the buttons and events:
   • ContinueButton → On Click () → CoopDemoController → OnLoginClicked()
   • HostButton → On Click () → CoopDemoController → OnHostClicked()
   • JoinButton → On Click () → CoopDemoController → OnJoinClicked()
   • SceneEventRouter's PlayerJoined binding → On Received → CoopDemoController → OnPlayerJoinedReceived()
   • SceneEventRouter's PickupCollected binding → On Received → CoopDemoController → OnPickupCollectedBroadcastReceived()
   • SceneEventRouter's PlayerLeft binding → On Received → CoopDemoController → OnPlayerLeftBroadcastReceived()

That's every wiring step. CoopDemoController.cs ships with the package — nothing left to write. Expand below if you'd like to see what it actually does:

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

public class CoopDemoController : MonoBehaviour
{
    public static CoopDemoController 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 scoreboardText;

    public CoopPlayerController[] playerSlots;
    public CoopPickup[] pickups;

    private RelayConnectionManager relay;
    private string displayName = "Player";
    private readonly Dictionary<int, int> _scores = new();

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

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

        ShowLogin();
    }

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

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

    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("[CoopDemo] Connection lost: " + reason);
        // Additive -- a failed host/join attempt never reaches Gameplay, so the player is
        // still on the Lobby panel to see this.
        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($"[CoopDemo] Failed to connect within {ConnectTimeoutSeconds}s."); yield break; }

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

        ConfigurePlayerSlots();
        RefreshScoreboard();
        ShowGameplay();
    }

    // Assigns each of the 4 pre-placed avatar slots to a network player id and decides
    // whether THIS client drives it (the slot matching relay.LocalUserId) or only receives
    // its position via NetCrafterSyncBinding. Every client independently computes the same
    // assignment -- ids are always 0 (host) through 3 (third joiner) by construction, so no
    // broadcast is needed to agree on which slot is whose.
    private void ConfigurePlayerSlots()
    {
        int myId = relay.LocalUserId;
        for (int i = 0; i < playerSlots.Length; i++)
        {
            var slot = playerSlots[i];
            if (slot == null) continue;
            bool mine = i == myId;
            slot.Configure(i, mine);

            var binding = slot.GetComponent<NetCrafterSyncBinding>();
            if (binding != null)
            {
                binding.Configure(i, mine);
                binding.enabled = true;
            }
        }
    }

    // Host-only: fires when RelayConnectionManager detects a joiner has stopped responding.
    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
    }

    // Called by a CoopPickup when the LOCAL player's avatar touches it.
    public void RequestCollectPickup(int pickupId)
    {
        if (relay.IsHost)
        {
            // Same reasoning as the chat tutorial's OnSendClicked -- Send() has no implicit
            // destination on the host, so host-originated actions call the same
            // host-authoritative logic (CoopGameState.TryCollectPickup) directly instead of
            // routing through a message the host can't send to itself, and broadcast
            // directly instead of relying on HandleCollectPickup to run for a message that
            // was never actually sent.
            if (CoopGameState.TryCollectPickup(pickupId, relay.LocalUserId, out int newScore))
            {
                var result = new PickupCollectedEvent { pickupId = pickupId, collectorPlayerId = relay.LocalUserId, newScore = newScore };
                relay.BroadcastToAll("PickupCollected", result.Serialize(), true);
                OnPickupCollectedReceived(pickupId, relay.LocalUserId, newScore);
            }
        }
        else
        {
            new CollectPickupRequest { pickupId = pickupId }.Send(relay);
        }
    }

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

    public void OnPickupCollectedBroadcastReceived()
    {
        var ev = (PickupCollectedEvent)NetCrafterSceneEventRouter.Instance.GetLastPayload("PickupCollected");
        OnPickupCollectedReceived(ev.pickupId, ev.collectorPlayerId, ev.newScore);
    }

    private void OnPickupCollectedReceived(int pickupId, int collectorPlayerId, int newScore)
    {
        foreach (var pickup in pickups)
        {
            if (pickup != null && pickup.pickupId == pickupId) { pickup.MarkCollected(); break; }
        }
        _scores[collectorPlayerId] = newScore;
        RefreshScoreboard();
    }

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

    private void OnPlayerLeftReceived(int playerId)
    {
        CoopGameState.PlayerNames.Remove(playerId);
        _scores.Remove(playerId);
        RefreshScoreboard();
        // The disconnected player's avatar is simply left at its last known position -- no
        // more sync updates arrive for it, but nothing removes or hides it. A real game would
        // likely grey it out or despawn it; kept simple here on purpose.
    }

    private void RefreshScoreboard()
    {
        var sb = new StringBuilder();
        foreach (var kv in _scores)
        {
            string name = CoopGameState.PlayerNames.TryGetValue(kv.Key, out var n) ? n : $"Player{kv.Key}";
            sb.AppendLine($"{name}: {kv.Value}");
        }
        if (scoreboardText != null) scoreboardText.text = sb.ToString();
    }
}

A finished reference scene with all of the above already wired up lives at Assets/PivecLabs/Examples/CoopDemo/CoopDemoScene.unity.

1. Build the scene (File → Build Settings → Build), or use multiple Editor instances if your license supports it.
2. Run one copy — this is the host. Enter a name, Continue, Host Game. The join code shows on the Lobby panel for a few seconds before moving on to the arena automatically.
3. Run 1–3 more copies — these are joiners (2-4 total players works the same way). Enter a name, Continue, type in the join code, Join Game.
4. Move each copy with WASD. Every avatar should move smoothly on its own client and, with a small network delay, on every other client too.
5. Walk any avatar onto a pickup. It should disappear immediately on the collector's own screen (optimistic local hide) and shortly after on every other screen too, with the scoreboard updating everywhere to show that player's score incremented by exactly one.
6. Walk into the rotating hazard. Your own avatar should snap back to its spawn point — visible to every other client as an ordinary (if abrupt) position update, since it rides the same sync path as normal movement.
7. Quit one joiner's copy mid-session (close the window, or kill the process). After a short delay (host-side peer-timeout detection), the remaining copies' scoreboards should drop that player, and everyone else keeps playing normally.

If pickups aren't syncing but avatars are moving, check the Console for HandleCollectPickup logs on the host's copy — same troubleshooting instinct as Chat's HandleSendChat. If avatars aren't syncing at all, see Common Mistakes below before assuming the network itself 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