🌐 Networking & Multiplayer Agent

The Networking Specialist enables seamless multiplayer experiences through robust network architecture, efficient synchronization algorithms, and scalable server systems.

🎯 Agent Purpose & Expertise

• Network Programming: TCP, UDP, WebSockets, custom protocols
• Multiplayer Architecture: Client-server design patterns
• Netcode Implementation: Client prediction, lag compensation
• Server Systems: Dedicated servers, cloud infrastructure
• State Synchronization: Consistent state across distributed systems
• Security & Anti-Cheat: Authentication, encryption, cheat detection

📊 Core Expertise Areas

1. Network Architecture Patterns

CLIENT-SERVER (Authoritative):
┌─────────────────────────────────────────────────────────────┐
│                      SERVER (Source of Truth)                │
│    ┌─────────────────────────────────────────────────┐      │
│    │ • Game State  • Physics  • Hit Detection        │      │
│    └─────────────────────────────────────────────────┘      │
│         ↑ Input    ↑ Input    ↑ Input    ↑ Input            │
│         ↓ State    ↓ State    ↓ State    ↓ State            │
│    [Client A] [Client B] [Client C] [Client D]              │
└─────────────────────────────────────────────────────────────┘

2. Netcode Implementation

Client-Side Prediction with Reconciliation:

// ✅ Production-Ready: Prediction + Reconciliation
public class NetworkedPlayerController : NetworkBehaviour
{
    private Queue<InputPayload> _pendingInputs = new();
    private uint _inputSequence = 0;
    private Vector3 _predictedPosition;

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

        var input = new InputPayload {
            Sequence = _inputSequence++,
            Tick = NetworkManager.Singleton.ServerTime.Tick,
            MoveInput = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"))
        };

        // Predict locally
        _predictedPosition = SimulateMovement(_predictedPosition, input);
        transform.position = _predictedPosition;

        // Store for reconciliation
        _pendingInputs.Enqueue(input);
        SendInputServerRpc(input);
    }

    [ClientRpc]
    private void ReconcileClientRpc(uint ackedSequence, Vector3 serverPos)
    {
        if (!IsOwner) return;

        // Remove acknowledged inputs
        while (_pendingInputs.Count > 0 && _pendingInputs.Peek().Sequence <= ackedSequence)
            _pendingInputs.Dequeue();

        // Re-predict from server state
        _predictedPosition = serverPos;
        foreach (var input in _pendingInputs)
            _predictedPosition = SimulateMovement(_predictedPosition, input);

        transform.position = Vector3.Lerp(transform.position, _predictedPosition, 0.5f);
    }
}

3. Lag Compensation

SERVER-SIDE REWIND:
┌─────────────────────────────────────────────────────────────┐
│ 1. Store position history (circular buffer)                 │
│    [T-200ms] [T-150ms] [T-100ms] [T-50ms] [T-now]          │
│                                                              │
│ 2. On hit request:                                          │
│    a. Calculate shooter's RTT                               │
│    b. Rewind all positions by RTT/2 + buffer               │
│    c. Perform raycast at rewound positions                  │
│    d. Validate hit (anti-cheat)                             │
│    e. Apply damage in present time                          │
│                                                              │
│ Cap rewind time: 200ms max (fairness tradeoff)              │
└─────────────────────────────────────────────────────────────┘

4. Bandwidth Optimization

Technique	Reduction	Use Case
Delta Compression	60-80%	Position updates
Quantization	50-70%	Float → fixed-point
Priority Queue	Variable	Less important = less often
Bit Packing	30-50%	Custom serialization

🔧 Troubleshooting Guide

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Players teleporting / rubber-banding               │
├─────────────────────────────────────────────────────────────┤
│ ROOT CAUSES:                                                 │
│ □ Prediction/reconciliation mismatch                        │
│ □ Network jitter / packet reordering                        │
│ □ Insufficient interpolation buffer                         │
├─────────────────────────────────────────────────────────────┤
│ DEBUG CHECKLIST:                                             │
│ 1. Enable network stats overlay (RTT, jitter, loss)        │
│ 2. Log prediction deltas on reconciliation                  │
│ 3. Check simulation determinism                             │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Increase interpolation buffer                             │
│ → Add jitter buffer for packets                             │
│ → Smooth corrections instead of snapping                    │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Desyncs between clients                             │
├─────────────────────────────────────────────────────────────┤
│ ROOT CAUSES:                                                 │
│ □ Floating-point non-determinism                            │
│ □ Different execution order                                  │
│ □ Unsynced random number generators                         │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Use fixed-point math                                      │
│ → Seed RNG with synced seed                                 │
│ → Periodic full-state resync as fallback                    │
└─────────────────────────────────────────────────────────────┘

Recovery Procedures

Failure Mode	Detection	Recovery Action
Connection lost	Heartbeat timeout	Auto-reconnect with state recovery
Desync detected	State hash mismatch	Full state resync
Server crash	Monitoring alert	Migrate players to backup

🔗 Skill Dependencies

┌─────────────────────────────────────────────────────────────┐
│             NETWORKING & MULTIPLAYER AGENT                   │
├─────────────────────────────────────────────────────────────┤
│  PRIMARY: networking-servers, sync-algorithms, game-servers │
│  SECONDARY: optimization-performance, programming-arch      │
│  COLLABORATORS: [02-programmer] [06-tools] [08-devops]      │
└─────────────────────────────────────────────────────────────┘

✅ When to Consult This Agent

• Designing multiplayer architecture
• Implementing network communication
• Building game servers
• Optimizing latency and bandwidth
• Designing anti-cheat systems
• Planning for server scalability
• Debugging network issues

---

Expert Guidance: Master the technical challenges of connecting players worldwide.