Godot Multiplayer

• MANDATORY: Server is authoritative — clients send inputs, server processes game state
• Use MultiplayerSpawner for automatic node replication across peers
• Use MultiplayerSynchronizer for continuous state sync (positions, health, etc.)
• RPCs (@rpc) for discrete events (damage, ability use, chat)
• Authority: set_multiplayer_authority() to assign which peer controls each node

RPC Best Practices

# Server-side validation for all client RPCs
@rpc("any_peer", "call_local", "reliable")
func request_attack(target_id: int) -> void:
    if not multiplayer.is_server():
        return
    var sender_id := multiplayer.get_remote_sender_id()
    var attacker := get_player(sender_id)
    var target := get_player(target_id)
    
    # Server validates: in range? cooldown ready? alive?
    if not _validate_attack(attacker, target):
        return
    
    _apply_damage(target, attacker.get_damage())
    # Notify all clients
    notify_attack.rpc(sender_id, target_id, attacker.get_damage())

@rpc("authority", "call_local", "reliable")
func notify_attack(attacker_id: int, target_id: int, damage: float) -> void:
    # Clients play VFX/SFX
    _play_attack_vfx(attacker_id, target_id)

Network Topology

Client-Side Prediction

# Client predicts movement locally
func _physics_process(delta: float) -> void:
    if is_multiplayer_authority():
        var input := _get_input()
        # Apply locally immediately (prediction)
        _apply_movement(input, delta)
        # Send input to server
        send_input.rpc_id(1, input, _tick)
        _tick += 1

# Server reconciliation
@rpc("any_peer", "call_local", "unreliable_ordered")
func send_input(input: Dictionary, tick: int) -> void:
    if not multiplayer.is_server():
        return
    var sender_id := multiplayer.get_remote_sender_id()
    # Server applies and sends authoritative state back
    var state := _apply_movement_server(sender_id, input)
    reconcile_state.rpc_id(sender_id, state, tick)

Anti-Pattern Watchlist

• ❌ Trusting client-sent game state (positions, health, scores)
• ❌ @rpc("any_peer") without server-side validation
• ❌ Syncing every property every frame (bandwidth explosion)
• ❌ No interpolation for remote players (teleporting movement)
• ❌ No lag compensation for hit detection
• ❌ Using reliable for position updates (use unreliable_ordered)

Phases

Phase 1 — Network Setup

• Choose network topology (client-server, P2P, relay)
• Configure ENetMultiplayerPeer or WebSocketMultiplayerPeer
• Set up lobby system: create/join/list games
• Player connection handling: peer_connected, peer_disconnected
• Network identity: unique peer IDs, player data association

Phase 2 — State Synchronization

• MultiplayerSpawner: auto-spawn player scenes on all peers
• MultiplayerSynchronizer: continuous sync for transform, animation state
• Configure replication intervals (positions: 20Hz, health: on-change)
• Interpolation for remote player movement (smooth rendering between updates)
• Delta compression for bandwidth optimization

Phase 3 — Server Authority & Prediction

• Server-authoritative game logic (combat, economy, progression)
• Client-side prediction for local player movement
• Server reconciliation (correct client state from server truth)
• Lag compensation for hit detection (server rewinds time)
• Input buffering to handle network jitter

Phase 4 — Production

• Reconnection handling (player disconnects and reconnects)
• Matchmaking system (skill-based or random)
• Anti-cheat: server validates all client RPCs
• Network statistics: ping display, packet loss monitoring
• Dedicated server build (headless Godot, no rendering)
• Stress testing with multiple bots

Execution Checklist

• Network peer configured (ENet/WebSocket)
• Lobby system (create/join/list)
• Player connection and disconnection handling
• MultiplayerSpawner for player scenes
• MultiplayerSynchronizer for state sync
• RPC communication layer with server validation
• Server-authoritative game logic
• Client-side prediction for movement
• Server reconciliation
• Interpolation for remote players
• Lag compensation for hit detection
• Reconnection handling
• Bandwidth optimization (delta compression, unreliable for positions)
• Network stats display (ping, packet loss)
• Dedicated server build (headless)
• Stress tested with bots