🏆 Lesson 6.5: Mini-Project — A Small Authoritative Multiplayer Prototype

The Architecture

Every piece maps onto the "server writes, clients request" model. Here's the whole loop:

Step 1: Scene & Prefabs

1. A scene with a ground plane, a NetworkManager (Unity Transport), and the ConnectionMenu from Lesson 6.1.
2. Player prefab: a capsule + NetworkObject + a NetworkTransform (leave it server-authoritative) + a trigger collider (Is Trigger on) + the scripts below. Assign it as the NetworkManager's Player Prefab.
3. Coin prefab: a small sphere + NetworkObject + NetworkTransform + the Coin script + a (non-trigger) collider. Register it in the NetworkManager's network prefabs list.
4. An empty CoinSpawner object with a NetworkObject and the spawner script.

Step 2: Authoritative Movement

The owner reads input and requests movement; the server applies it, and the server-authoritative NetworkTransform replicates the new position to everyone. The client never moves its own transform directly:

using Unity.Netcode;
using UnityEngine;

public class PlayerMovement : NetworkBehaviour
{
    [SerializeField] float speed = 5f;

    void Update()
    {
        if (!IsOwner) return;   // only drive the avatar I own

        var input = new Vector3(Input.GetAxis("Horizontal"), 0f, Input.GetAxis("Vertical"));
        if (input.sqrMagnitude > 0.001f)
            MoveRpc(input.normalized);   // request → runs on the server
    }

    [Rpc(SendTo.Server)]
    void MoveRpc(Vector3 direction)
    {
        // Executes on the SERVER. It owns the transform; NetworkTransform replicates it.
        transform.position += direction * speed * Time.deltaTime;
    }
}

Step 3: Coins & Pickups

The coin is a trivial NetworkBehaviour carrying a value. The server spawns a field of them on start:

using Unity.Netcode;
using UnityEngine;

public class Coin : NetworkBehaviour
{
    public int Value = 10;
}

public class CoinSpawner : NetworkBehaviour
{
    [SerializeField] GameObject coinPrefab;
    [SerializeField] int count = 20;
    [SerializeField] float range = 8f;

    public override void OnNetworkSpawn()
    {
        if (!IsServer) return;   // ONLY the server spawns

        for (int i = 0; i < count; i++)
        {
            var pos = new Vector3(Random.Range(-range, range), 0.5f, Random.Range(-range, range));
            var go  = Instantiate(coinPrefab, pos, Quaternion.identity);
            go.GetComponent<NetworkObject>().Spawn();   // replicate to all clients
        }
    }
}

Pickup detection runs on the server via the player's trigger. Because movement is server-authoritative, the physics overlap happens on the server — so the trigger fires there, and we guard with IsServer to be safe:

using Unity.Netcode;
using UnityEngine;

public class PlayerScore : NetworkBehaviour
{
    // server writes, everyone reads
    public NetworkVariable<int> Score = new NetworkVariable<int>(
        0, NetworkVariableReadPermission.Everyone, NetworkVariableWritePermission.Server);

    void OnTriggerEnter(Collider other)
    {
        if (!IsServer) return;   // authoritative pickup only on the server

        if (other.TryGetComponent(out Coin coin) && coin.NetworkObject.IsSpawned)
        {
            Score.Value += coin.Value;        // NetworkVariable → replicates to all
            coin.NetworkObject.Despawn();      // remove the coin for everyone
        }
    }
}

Notice there's no client-supplied number anywhere — the server reads the coin's own value, checks it's still spawned, awards points, and despawns it. A cheat-client can't fake a pickup because it can't run this code; it only ever moves (a validated request), and the server decides the rest.

Step 4: Synced Score & UI

The score is already a NetworkVariable, so the UI just subscribes to changes — no polling, and correct on every machine including late joiners:

using Unity.Netcode;
using UnityEngine;
using TMPro;   // or UnityEngine.UI.Text

public class ScoreLabel : NetworkBehaviour
{
    [SerializeField] TMP_Text label;
    PlayerScore score;

    public override void OnNetworkSpawn()
    {
        score = GetComponent<PlayerScore>();
        score.Score.OnValueChanged += OnScoreChanged;
        OnScoreChanged(0, score.Score.Value);   // init to current (late joiners)
    }

    public override void OnNetworkDespawn()
    {
        if (score != null) score.Score.OnValueChanged -= OnScoreChanged;
    }

    void OnScoreChanged(int previous, int current) =>
        label.text = $"{OwnerClientId}: {current}";
}

Each player object shows its own score above its head, updated the instant the server changes it — and every client sees every player's score, because the NetworkVariable replicates to all.

Step 5: Play It

1. Build the project. Run one instance, click Host; run a second, click Client (connects to 127.0.0.1).
2. Move each avatar with WASD. Each window controls only its own player, but both avatars move in both windows — server-authoritative movement replicating.
3. Drive over coins. They vanish for everyone, and the collector's score ticks up on every scoreboard.
4. Confirm authority: nothing a client does changes shared state except through the server. That's a correct multiplayer game.

What You Built & Extending

• Win condition. Add a match timer and a server-side check that ends the round and broadcasts the winner with a SendTo.ClientsAndHost RPC.
• Respawning coins. Have the server spawn a new coin whenever one is collected, keeping the field full.
• Smoother movement. Send input at a fixed tick rate instead of every frame, or explore client prediction (a specialisation — see the finale's "where to go next").
• Player names. A FixedString32Bytes NetworkVariable set on spawn, shown on the scoreboard.

Quick Quiz

Summary

🚀 What's Next?

That completes the Netcode pillar. The final pillar is about your productivity and shipping. Module 7: Editor Tooling & Addressables begins with Lesson 7.1: Custom Inspectors & Property Drawers — bending the Editor itself to your workflow.