Unity Game Engine Series Part 12: Multiplayer & Networking

1. Networking Models

1.1 Client-Server Architecture

In a client-server model, one machine (the server) is the authoritative source of truth. All game state changes must be validated by the server, and clients receive state updates. This is the industry standard for competitive games because it provides a single point of authority that prevents most forms of cheating.

1.2 Peer-to-Peer & Relay Servers

In peer-to-peer (P2P), all clients communicate directly with each other without a central server. Each client runs the full game simulation. This eliminates server hosting costs but introduces challenges around trust (who resolves conflicts?) and NAT traversal (how do players behind routers connect?).

Relay servers are a hybrid approach: a lightweight server forwards packets between players without running the game simulation. This solves NAT traversal while keeping costs low. Unity Relay Service provides this out of the box.

1.3 Choosing the Right Model

2. Netcode for GameObjects

Unity's official networking solution is Netcode for GameObjects (NGO). It provides NetworkManager, NetworkBehaviour, NetworkVariable, RPCs, and object spawning out of the box.

2.1 NetworkManager & NetworkBehaviour

using Unity.Netcode;
using UnityEngine;

// NetworkBehaviour is the networked version of MonoBehaviour
public class PlayerNetwork : NetworkBehaviour
{
    [SerializeField] private float moveSpeed = 5f;

    // NetworkVariable: automatically synced from server to all clients
    private NetworkVariable<Vector3> netPosition = new NetworkVariable<Vector3>(
        default,
        NetworkVariableReadPermission.Everyone,
        NetworkVariableWritePermission.Server
    );

    private NetworkVariable<int> netHealth = new NetworkVariable<int>(
        100,
        NetworkVariableReadPermission.Everyone,
        NetworkVariableWritePermission.Server
    );

    public override void OnNetworkSpawn()
    {
        // Called when this object is spawned on the network
        if (IsOwner)
        {
            Debug.Log("I am the local player!");
            // Set up camera, input, etc.
        }

        // Listen for health changes
        netHealth.OnValueChanged += OnHealthChanged;
    }

    public override void OnNetworkDespawn()
    {
        netHealth.OnValueChanged -= OnHealthChanged;
    }

    private void Update()
    {
        if (!IsOwner) return; // Only the owner processes input

        Vector3 input = new Vector3(
            Input.GetAxisRaw("Horizontal"),
            0,
            Input.GetAxisRaw("Vertical")
        );

        if (input.sqrMagnitude > 0)
        {
            // Send movement request to server
            MoveServerRpc(input.normalized);
        }
    }

    private void OnHealthChanged(int oldValue, int newValue)
    {
        Debug.Log($"Health changed: {oldValue} -> {newValue}");
        // Update health bar UI...
    }
}

2.2 ServerRpc & ClientRpc

RPCs (Remote Procedure Calls) are the primary way clients and servers communicate specific actions. ServerRpc flows from client to server; ClientRpc flows from server to all (or specific) clients.

using Unity.Netcode;
using UnityEngine;

public class PlayerCombat : NetworkBehaviour
{
    [SerializeField] private float attackRange = 2f;
    [SerializeField] private int attackDamage = 25;
    [SerializeField] private float attackCooldown = 0.5f;

    private float lastAttackTime;

    private void Update()
    {
        if (!IsOwner) return;

        if (Input.GetMouseButtonDown(0) && Time.time > lastAttackTime + attackCooldown)
        {
            lastAttackTime = Time.time;
            // Tell the server we want to attack
            AttackServerRpc();
        }
    }

    // ServerRpc: called on a client, executed on the server
    [ServerRpc]
    private void AttackServerRpc()
    {
        // Server validates and processes the attack
        // (The server is the authority; it decides if the attack hits)
        Collider[] hits = Physics.OverlapSphere(transform.position, attackRange);
        foreach (var hit in hits)
        {
            if (hit.TryGetComponent<PlayerHealth>(out var health) &&
                hit.GetComponent<NetworkObject>().OwnerClientId != OwnerClientId)
            {
                health.TakeDamage(attackDamage);
                // Notify all clients about the hit
                OnAttackHitClientRpc(hit.transform.position);
            }
        }
    }

    // ClientRpc: called on the server, executed on all clients
    [ClientRpc]
    private void OnAttackHitClientRpc(Vector3 hitPosition)
    {
        // All clients play hit effect at the position
        // Spawn particles, play sound, screen shake, etc.
        Debug.Log($"Hit at {hitPosition}!");
    }

    // ServerRpc with parameters and RequireOwnership
    [ServerRpc]
    private void MoveServerRpc(Vector3 direction)
    {
        // Server validates and applies movement
        Vector3 newPos = transform.position + direction * 5f * Time.deltaTime;
        transform.position = newPos;
    }

    // ClientRpc targeting specific clients
    [ClientRpc]
    private void NotifyClientRpc(string message, ClientRpcParams rpcParams = default)
    {
        Debug.Log($"Server says: {message}");
    }
}

2.3 NetworkVariable & Ownership

NetworkVariables automatically synchronize data from the server to clients. They support value change callbacks and configurable read/write permissions:

using Unity.Netcode;
using UnityEngine;

public class PlayerHealth : NetworkBehaviour
{
    // Only the server can write; everyone can read
    public NetworkVariable<int> Health = new NetworkVariable<int>(
        100,
        NetworkVariableReadPermission.Everyone,
        NetworkVariableWritePermission.Server
    );

    // Player name: set by owner, readable by all
    public NetworkVariable<Unity.Collections.FixedString64Bytes> PlayerName =
        new NetworkVariable<Unity.Collections.FixedString64Bytes>(
            default,
            NetworkVariableReadPermission.Everyone,
            NetworkVariableWritePermission.Owner
        );

    // NetworkList for collections
    public NetworkList<int> Inventory;

    private void Awake()
    {
        Inventory = new NetworkList<int>();
    }

    public override void OnNetworkSpawn()
    {
        if (IsOwner)
        {
            PlayerName.Value = $"Player_{OwnerClientId}";
        }

        Health.OnValueChanged += (oldVal, newVal) =>
        {
            Debug.Log($"{PlayerName.Value} health: {oldVal} -> {newVal}");
            if (newVal <= 0) HandleDeath();
        };
    }

    // Only callable on the server (since Health is server-write)
    public void TakeDamage(int amount)
    {
        if (!IsServer) return;
        Health.Value = Mathf.Max(0, Health.Value - amount);
    }

    public void Heal(int amount)
    {
        if (!IsServer) return;
        Health.Value = Mathf.Min(100, Health.Value + amount);
    }

    private void HandleDeath()
    {
        if (IsServer)
        {
            // Server handles respawn logic
            RespawnClientRpc();
        }
    }

    [ClientRpc]
    private void RespawnClientRpc()
    {
        Debug.Log($"{PlayerName.Value} died! Respawning...");
    }
}

3. Synchronization

3.1 State Sync vs Input Sync

3.2 Client-Side Prediction & Server Reconciliation

Client-side prediction is the key technique that makes networked games feel responsive. Instead of waiting for the server to confirm each action, the client immediately predicts the result locally. When the server's authoritative response arrives, the client corrects any misprediction.

using Unity.Netcode;
using UnityEngine;
using System.Collections.Generic;

public class PredictedPlayerMovement : NetworkBehaviour
{
    [SerializeField] private float moveSpeed = 8f;
    [SerializeField] private CharacterController controller;

    // Buffer of predicted inputs for reconciliation
    private struct InputPayload
    {
        public uint Tick;
        public Vector3 Direction;
    }

    private struct StatePayload
    {
        public uint Tick;
        public Vector3 Position;
    }

    private Queue<InputPayload> inputBuffer = new Queue<InputPayload>();
    private uint currentTick = 0;
    private const int BUFFER_SIZE = 1024;

    // Server-confirmed state
    private NetworkVariable<StatePayload> serverState = new NetworkVariable<StatePayload>();

    private StatePayload[] predictionBuffer = new StatePayload[BUFFER_SIZE];

    public override void OnNetworkSpawn()
    {
        serverState.OnValueChanged += OnServerStateChanged;
    }

    private void Update()
    {
        if (!IsOwner) return;

        currentTick++;
        Vector3 input = new Vector3(
            Input.GetAxisRaw("Horizontal"), 0, Input.GetAxisRaw("Vertical")
        ).normalized;

        // 1. Apply input locally (prediction)
        controller.Move(input * moveSpeed * Time.deltaTime);

        // 2. Store prediction for later reconciliation
        predictionBuffer[currentTick % BUFFER_SIZE] = new StatePayload
        {
            Tick = currentTick,
            Position = transform.position
        };

        // 3. Send input to server
        SendInputServerRpc(new InputPayload { Tick = currentTick, Direction = input });
    }

    [ServerRpc]
    private void SendInputServerRpc(InputPayload input)
    {
        // Server applies input authoritatively
        controller.Move(input.Direction * moveSpeed * Time.fixedDeltaTime);

        // Broadcast authoritative state
        serverState.Value = new StatePayload
        {
            Tick = input.Tick,
            Position = transform.position
        };
    }

    private void OnServerStateChanged(StatePayload oldState, StatePayload newState)
    {
        if (!IsOwner) return;

        // Compare server state with our prediction
        StatePayload predicted = predictionBuffer[newState.Tick % BUFFER_SIZE];
        float error = Vector3.Distance(predicted.Position, newState.Position);

        if (error > 0.01f)
        {
            // Misprediction! Snap to server position and re-simulate
            Debug.Log($"Reconciliation: error={error:F3}m at tick {newState.Tick}");
            transform.position = newState.Position;

            // Re-apply all inputs since the corrected tick
            // (This is the reconciliation step)
        }
    }
}

3.3 Lag Compensation & Interpolation

Snapshot interpolation smooths remote player movement by rendering them slightly in the past (typically 100-200ms) and interpolating between received snapshots. This eliminates jitter from irregular packet delivery.

using UnityEngine;
using System.Collections.Generic;

public class NetworkInterpolation : MonoBehaviour
{
    [SerializeField] private float interpolationDelay = 0.1f; // 100ms behind

    private struct Snapshot
    {
        public float Timestamp;
        public Vector3 Position;
        public Quaternion Rotation;
    }

    private List<Snapshot> snapshotBuffer = new List<Snapshot>();
    private float renderTimestamp;

    public void ReceiveSnapshot(Vector3 position, Quaternion rotation, float serverTime)
    {
        snapshotBuffer.Add(new Snapshot
        {
            Timestamp = serverTime,
            Position = position,
            Rotation = rotation
        });

        // Keep buffer trimmed (max 30 snapshots)
        while (snapshotBuffer.Count > 30)
            snapshotBuffer.RemoveAt(0);
    }

    private void Update()
    {
        renderTimestamp = Time.time - interpolationDelay;

        // Find the two snapshots surrounding our render time
        for (int i = 0; i < snapshotBuffer.Count - 1; i++)
        {
            if (snapshotBuffer[i].Timestamp <= renderTimestamp &&
                snapshotBuffer[i + 1].Timestamp >= renderTimestamp)
            {
                float t = Mathf.InverseLerp(
                    snapshotBuffer[i].Timestamp,
                    snapshotBuffer[i + 1].Timestamp,
                    renderTimestamp
                );

                // Interpolate between snapshots
                transform.position = Vector3.Lerp(
                    snapshotBuffer[i].Position,
                    snapshotBuffer[i + 1].Position, t
                );
                transform.rotation = Quaternion.Slerp(
                    snapshotBuffer[i].Rotation,
                    snapshotBuffer[i + 1].Rotation, t
                );
                return;
            }
        }

        // If no valid pair found, extrapolate from last known
        if (snapshotBuffer.Count > 0)
        {
            transform.position = snapshotBuffer[snapshotBuffer.Count - 1].Position;
        }
    }
}

4. Multiplayer Challenges

4.1 Latency & Bandwidth Optimization

Bandwidth optimization techniques include:

• Delta compression: Only send values that changed since the last snapshot
• Quantization: Reduce float precision (e.g., 2 bytes instead of 4 for position)
• Interest management: Only send data about nearby objects (area of interest)
• Variable tick rate: Send important objects more frequently than background objects
• Bit packing: Pack boolean flags into single bytes

4.2 Cheating Prevention & Security

using Unity.Netcode;
using UnityEngine;

public class ServerValidation : NetworkBehaviour
{
    private const float MAX_SPEED = 10f;
    private const float SPEED_TOLERANCE = 1.2f; // 20% tolerance for lag
    private Vector3 lastValidatedPosition;
    private float lastValidationTime;

    [ServerRpc]
    public void MoveRequestServerRpc(Vector3 requestedPosition)
    {
        if (!IsServer) return;

        float timeDelta = Time.time - lastValidationTime;
        float maxDistance = MAX_SPEED * timeDelta * SPEED_TOLERANCE;
        float actualDistance = Vector3.Distance(lastValidatedPosition, requestedPosition);

        if (actualDistance > maxDistance)
        {
            // Possible speed hack! Reject and snap back
            Debug.LogWarning($"Client {OwnerClientId}: speed violation " +
                           $"(moved {actualDistance:F1}m, max {maxDistance:F1}m)");
            CorrectPositionClientRpc(lastValidatedPosition);
            return;
        }

        // Validate: is the position inside valid bounds?
        if (!IsPositionValid(requestedPosition))
        {
            Debug.LogWarning($"Client {OwnerClientId}: invalid position");
            CorrectPositionClientRpc(lastValidatedPosition);
            return;
        }

        // Accept the move
        lastValidatedPosition = requestedPosition;
        lastValidationTime = Time.time;
        transform.position = requestedPosition;
    }

    private bool IsPositionValid(Vector3 pos)
    {
        // Check bounds, collision, no-clip, etc.
        return pos.y >= 0 && pos.y < 100 &&
               !Physics.CheckSphere(pos, 0.3f, LayerMask.GetMask("Walls"));
    }

    [ClientRpc]
    private void CorrectPositionClientRpc(Vector3 correctedPosition)
    {
        if (IsOwner) transform.position = correctedPosition;
    }
}

4.3 Transport Layer & Protocols

Exercises & Self-Assessment

Conclusion & Next Steps

Multiplayer networking is the most challenging aspect of game development, but with the right knowledge and tools, it's entirely manageable. Here are the key takeaways from Part 12:

• Client-server authoritative is the industry standard for competitive games; the server validates all game state and clients trust the server's authority
• Netcode for GameObjects provides NetworkManager, NetworkBehaviour, NetworkVariable, and RPCs (ServerRpc/ClientRpc) for building networked games in Unity
• NetworkVariables are for persistent state (auto-synced to late joiners); RPCs are for events (fire-and-forget)
• Client-side prediction makes games feel responsive by predicting locally and reconciling with server corrections
• Snapshot interpolation smooths remote player movement by rendering 100-200ms behind and lerping between snapshots
• Lag compensation rewinds the world to the shooter's perspective time for fair hit detection
• Never trust the client: validate all inputs on the server to prevent speed hacks, teleport hacks, and damage manipulation
• UDP is preferred for real-time game data; TCP is used for reliable events like chat and matchmaking