Game Multiplayer Patterns

Le multiplayer est le domaine le plus complexe du game dev. Ce skill couvre les choix architecturaux et les patterns implémentation par moteur.

1. Decision tree — quel modèle netcode ?

Type de jeu
├── RTS / fighting / lockstep tactical
│   └── DETERMINISTIC LOCKSTEP (Photon Quantum, custom)
│       ✅ Sync parfait, peu de bandwidth
│       ❌ Rollback complexe, désync = bug fatal
│
├── FPS / action competitive (CS-like, Valorant, Apex)
│   └── CLIENT-SERVER + Client-side prediction + Server reconciliation + Lag compensation
│       ✅ Anti-cheat possible (server authoritative)
│       ❌ Coût serveur, complexité prediction
│
├── Co-op PvE / mid-scale (Among Us, Fall Guys)
│   ├── CLIENT-SERVER hosted (dedicated)
│   └── PEER-TO-PEER avec host elected (cheap)
│
├── MMO / persistent world
│   └── CLIENT-SERVER avec sharding + interest management
│
├── Turn-based / async
│   └── REST API + WebSocket pour notifications (pas de "vrai" netcode)
│
└── Local couch co-op
    └── Pas de netcode du tout — local multi-input

2. Patterns netcode core

Client-side prediction

Le client prédit immédiatement l'effet de ses inputs sans attendre le serveur. Donne une UX fluide.

// Unity NGO simplifié
public class PlayerController : NetworkBehaviour
{
    private struct InputPayload {
        public int tick;
        public Vector3 inputVector;
    }
    private struct StatePayload {
        public int tick;
        public Vector3 position;
        public Vector3 velocity;
    }

    private const int BUFFER_SIZE = 1024;
    private InputPayload[] inputBuffer = new InputPayload[BUFFER_SIZE];
    private StatePayload[] stateBuffer = new StatePayload[BUFFER_SIZE];

    private void HandleClientTick(int currentTick) {
        if (!IsOwner) return;

        var input = new InputPayload {
            tick = currentTick,
            inputVector = GetInput()
        };
        inputBuffer[currentTick % BUFFER_SIZE] = input;

        // Predict locally
        StatePayload predictedState = ProcessMovement(input);
        stateBuffer[currentTick % BUFFER_SIZE] = predictedState;

        // Send to server
        SendInputServerRpc(input);
    }
}

Server reconciliation

Le serveur valide chaque input. Si la prédiction client diverge, le client reconcilie : revient à l'état serveur authoritative et rejoue ses inputs locaux non-confirmés.

[ClientRpc]
private void ReceiveServerStateClientRpc(StatePayload serverState) {
    if (!IsOwner) return;

    StatePayload predictedState = stateBuffer[serverState.tick % BUFFER_SIZE];
    float positionError = Vector3.Distance(predictedState.position, serverState.position);

    if (positionError > 0.001f) {
        // Misprediction — reconcile
        transform.position = serverState.position;
        stateBuffer[serverState.tick % BUFFER_SIZE] = serverState;

        // Replay all unconfirmed inputs
        for (int tick = serverState.tick + 1; tick <= currentTick; tick++) {
            stateBuffer[tick % BUFFER_SIZE] = ProcessMovement(inputBuffer[tick % BUFFER_SIZE]);
        }
    }
}

Lag compensation (hit detection)

Quand le serveur reçoit un "I shot at this position" du client, il rewind l'état du monde au tick correspondant à la latence du client pour valider le tir.

T=100  | Server tick now
       | Player A shoots at T=95 (50ms ping)
       |
       v
[T=95] Server rewinds enemies to T=95 positions, validates hit, applies damage

Sans lag compensation, on tire toujours "à côté" car l'ennemi a bougé entre le moment où on l'a vu et le moment où le serveur reçoit le shoot.

Snapshot interpolation

Pour les autres joueurs qu'on ne contrôle pas, on interpole entre les snapshots serveur au lieu de les téléporter. Latence visuelle de 100-150ms = mouvements fluides.

3. Unity Netcode for GameObjects (NGO)

using Unity.Netcode;

public class HealthSystem : NetworkBehaviour
{
    public NetworkVariable<int> currentHealth = new NetworkVariable<int>(
        100,
        readPerm: NetworkVariableReadPermission.Everyone,
        writePerm: NetworkVariableWritePermission.Server
    );

    [ServerRpc]
    public void TakeDamageServerRpc(int amount) {
        if (!IsServer) return;
        currentHealth.Value -= amount;
    }

    [ClientRpc]
    private void PlayDeathEffectClientRpc() {
        // VFX local sur tous les clients
    }

    private void OnEnable() {
        currentHealth.OnValueChanged += OnHealthChanged;
    }
}

Setup connection :

• Unity Transport (UTP) : UDP, recommended
• Unity Relay : NAT punch-through gratuit jusqu'à X CCU
• Unity Lobby : matchmaking/lobby system

4. Mirror Networking (Unity, open source)

using Mirror;

public class Player : NetworkBehaviour
{
    [SyncVar(hook = nameof(OnHealthChanged))]
    private int health = 100;

    [Command]
    public void CmdTakeDamage(int amount) {
        health -= amount;
    }

    [ClientRpc]
    public void RpcPlayHitEffect() {
        // VFX
    }

    private void OnHealthChanged(int oldValue, int newValue) {
        UpdateHealthBar(newValue);
    }
}

Avantages Mirror vs NGO :

• Open source mature (depuis UNet)
• Plus de transports (KCP, Telepathy, Steamworks)
• Moins lock-in Unity
• Gratuit pour tout

5. Godot 4 high-level multiplayer

# server.gd
extends Node

const PORT = 7777
const MAX_CLIENTS = 32

func _ready() -> void:
    var peer := ENetMultiplayerPeer.new()
    peer.create_server(PORT, MAX_CLIENTS)
    multiplayer.multiplayer_peer = peer
    multiplayer.peer_connected.connect(_on_peer_connected)
    multiplayer.peer_disconnected.connect(_on_peer_disconnected)

func _on_peer_connected(id: int) -> void:
    print("Peer %d connected" % id)

# Player.gd avec MultiplayerSynchronizer
extends CharacterBody2D

@export var sync_position: bool = true

@rpc("any_peer", "call_local", "reliable")
func take_damage(amount: int) -> void:
    health -= amount
    if health <= 0:
        die.rpc()

@rpc("authority", "call_local", "reliable")
func die() -> void:
    queue_free()

Le MultiplayerSynchronizer node sync automatiquement les properties cochées dans l'inspector. Le MultiplayerSpawner gère la création/destruction d'entités replicated.

6. Photon Fusion (Unity, prediction + rollback)

Photon Fusion est une alternative payante mais très avancée :

• Prediction + rollback intégrés
• Tick rate déterministe
• Hosted ou self-hosted
• Cloud relay inclus

public class PlayerNetworked : NetworkBehaviour
{
    [Networked] public Vector3 NetworkedPosition { get; set; }
    [Networked] public int NetworkedHealth { get; set; }

    public override void FixedUpdateNetwork() {
        if (GetInput(out NetInput input)) {
            NetworkedPosition += input.movementVector * Runner.DeltaTime;
        }
    }
}

Pour les competitive games, Fusion est souvent le meilleur choix.

7. Matchmaking + Hosting

Service	Use case
Steam Lobby + Steam Networking	Jeux Steam, gratuit, P2P relay
Epic Online Services (EOS)	Cross-platform, gratuit, lobby + matchmaking + voice
Unity Lobby + Relay	Unity-native, freemium
PlayFab	Microsoft, lobby + matchmaking + servers
GameLift (AWS)	Dedicated servers managed, scale auto
Hathora	Edge dedicated servers, simple pricing
Edgegap	Edge dedicated servers, distributed

8. Anti-cheat

Anti-cheat	Use case
Easy Anti-Cheat (EAC)	Standard PC + console, gratuit Epic
BattlEye	Standard PC + console, payant
Wellbia XIGNCODE3	Asia market

Règle de base : aucun anti-cheat ne remplace un server-authoritative design. Tout ce qui est calculé côté client est piratable. Toujours valider côté serveur.

9. Anti-patterns

1. Client-authoritative health/damage — cheating trivial
2. Pas de prediction côté client — laggy unplayable
3. Snapshot rate trop élevé (60 Hz client) — bandwidth explosé, préférer 20-30 Hz interpolés
4. Pas de lag compensation sur hit detection — frustration "j'ai tiré sur lui mais je l'ai raté"
5. Send to all clients au lieu de Area-of-Interest — bandwidth O(N²), inscalable
6. Synchroniser des floats sans quantization — bandwidth gaspillé
7. TCP au lieu d'UDP pour les real-time games — head-of-line blocking
8. Pas de tests désync sur les builds lockstep — bugs invisibles en dev
9. Voicechat sur le même serveur que game logic — saturation
10. NAT punch-through fait main — utiliser un service relay
11. Pas d'authoritative server time — drift entre clients
12. Bandwidth illimité supposé — toujours mesurer (40 KB/s/client max raisonnable)

Checklist livraison

• Modèle architectural choisi (client-server / P2P / lockstep)
• Server-authoritative pour TOUT calcul critique
• Client-side prediction si action game
• Lag compensation si hit detection
• Snapshot interpolation pour autres joueurs
• Tick rate cohérent (20-60 Hz selon genre)
• Bandwidth budget mesuré
• Matchmaking + lobby intégré
• Anti-cheat (EAC ou BattlEye) si compétitif
• Tests réseau avec packet loss + jitter (clumsy / Network Link Conditioner)
• DDoS protection sur les serveurs publics
• Logging server-side pour debug

Quand déléguer

• Unity gameplay → skill unity-patterns (ce plugin)
• Godot gameplay → skill godot-patterns (ce plugin)
• Backend non-game (chat persistant, leaderboards) → skill realtime-websocket (atum-stack-backend)
• Architecture game → agent game-architect (ce plugin)

Ressources

• https://gafferongames.com/ (référence netcode)
• https://docs-multiplayer.unity3d.com/
• https://mirror-networking.gitbook.io/docs
• https://doc.photonengine.com/fusion
• https://docs.godotengine.org/en/stable/tutorials/networking/high_level_multiplayer.html