home / skills / pluginagentmarketplace / custom-plugin-game-developer / networking-servers

networking-servers skill

safe

This skill helps you design scalable multiplayer servers, implement client prediction, lag compensation, and anti-cheat measures.

npx playbooks add skill pluginagentmarketplace/custom-plugin-game-developer --skill networking-servers

Review the files below or copy the command above to add this skill to your agents.

Files (4)

SKILL.md

13.3 KB

---
name: networking-servers
version: "2.0.0"
description: |
  Multiplayer systems, netcode, game servers, synchronization, and anti-cheat.
  Build scalable, responsive multiplayer experiences.
sasmp_version: "1.3.0"
bonded_agent: 05-networking-multiplayer
bond_type: PRIMARY_BOND

parameters:
  - name: architecture
    type: string
    required: false
    validation:
      enum: [client_server, p2p, hybrid, dedicated]
  - name: framework
    type: string
    required: false
    validation:
      enum: [photon, mirror, netcode, fishnet, custom]

retry_policy:
  enabled: true
  max_attempts: 5
  backoff: exponential
  jitter: true

observability:
  log_events: [start, complete, error, reconnect]
  metrics: [latency_ms, packet_loss, bandwidth_kbps, player_count]
---

# Networking & Game Servers

## Network Architecture

```
CLIENT-SERVER (AUTHORITATIVE):
┌─────────────────────────────────────────────────────────────┐
│                   DEDICATED SERVER                           │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  • Authoritative game state                          │   │
│  │  • Physics simulation                                │   │
│  │  • Hit validation                                    │   │
│  │  • Anti-cheat checks                                 │   │
│  └─────────────────────────────────────────────────────┘   │
│       ↑↓              ↑↓              ↑↓              ↑↓    │
│   [Client A]    [Client B]    [Client C]    [Client D]     │
│   └─ Prediction  └─ Prediction  └─ Prediction  └─ Prediction│
└─────────────────────────────────────────────────────────────┘
```

## Netcode Implementation

### Client Prediction with Reconciliation

```csharp
// ✅ Production-Ready: Prediction + Reconciliation System
public class NetworkedMovement : NetworkBehaviour
{
    private struct InputPayload
    {
        public uint Tick;
        public uint Sequence;
        public Vector2 MoveInput;
        public bool Jump;
    }

    private Queue<InputPayload> _pendingInputs = new();
    private CircularBuffer<PlayerState> _stateHistory;
    private uint _inputSequence;

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

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

        // Predict locally (immediate response)
        ApplyInput(input);

        // Store for reconciliation
        _pendingInputs.Enqueue(input);
        _stateHistory.Add(GetCurrentState());

        // Send to server
        SendInputServerRpc(input);
    }

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

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

        // Check for prediction error
        var predictedState = _stateHistory.Get(ackedSequence);
        if (Vector3.Distance(predictedState.Position, serverState.Position) > 0.01f)
        {
            // Reconcile: reset to server state, replay pending inputs
            SetState(serverState);
            foreach (var input in _pendingInputs)
                ApplyInput(input);
        }
    }
}
```

### Lag Compensation

```csharp
// ✅ Production-Ready: Server-Side Rewind
public class LagCompensation : NetworkBehaviour
{
    private const int HISTORY_SIZE = 128;
    private const float MAX_REWIND_MS = 200f;

    private CircularBuffer<PositionSnapshot>[] _playerHistory;

    [ServerRpc]
    public void RequestHitValidationServerRpc(uint shooterClientId,
        Vector3 shootOrigin, Vector3 shootDirection, uint targetClientId)
    {
        // Get shooter's RTT
        float rtt = NetworkManager.ConnectedClients[shooterClientId].RTT;
        float rewindTime = Mathf.Min(rtt / 2f + 50f, MAX_REWIND_MS);

        // Get target's position at that time
        var targetPastPosition = GetPositionAtTime(targetClientId,
            Time.time - (rewindTime / 1000f));

        // Perform hit check at rewound position
        if (Physics.Raycast(shootOrigin, shootDirection, out var hit))
        {
            if (Vector3.Distance(hit.point, targetPastPosition) < 1f)
            {
                // Valid hit - apply damage
                ApplyDamage(targetClientId, 25);
            }
        }
    }
}
```

## Server Architecture

```
SCALABLE SERVER ARCHITECTURE:
┌─────────────────────────────────────────────────────────────┐
│  LOAD BALANCER (Global)                                      │
│         ↓                                                    │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  MATCHMAKING SERVICE                                  │   │
│  │  • Player queuing                                     │   │
│  │  • Skill-based matching                               │   │
│  │  • Session creation                                   │   │
│  └─────────────────────────────────────────────────────┘   │
│         ↓                                                    │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  GAME SERVERS (Auto-scaled)                          │   │
│  │  [US-East] [US-West] [EU] [Asia]                     │   │
│  │  Each region: 10-1000 instances                       │   │
│  └─────────────────────────────────────────────────────┘   │
│         ↓                                                    │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  DATABASE CLUSTER                                     │   │
│  │  • Player profiles                                    │   │
│  │  • Match history                                      │   │
│  │  • Leaderboards                                       │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘
```

## Bandwidth Optimization

| Technique | Savings | Implementation |
|-----------|---------|----------------|
| Delta Compression | 60-80% | Only send changed values |
| Quantization | 50-70% | Float → fixed-point |
| Bit Packing | 30-50% | Custom serialization |
| Interest Management | 70-90% | Only send relevant data |
| Priority Queue | Variable | Less important = less often |

## Anti-Cheat Strategies

```
ANTI-CHEAT LAYERS:
┌─────────────────────────────────────────────────────────────┐
│  LAYER 1: Server Authority                                   │
│  → All game state validated on server                       │
│  → Never trust client                                       │
├─────────────────────────────────────────────────────────────┤
│  LAYER 2: Sanity Checks                                      │
│  → Movement speed limits                                    │
│  → Action rate limits                                       │
│  → Position validation                                      │
├─────────────────────────────────────────────────────────────┤
│  LAYER 3: Statistical Detection                              │
│  → Inhuman accuracy patterns                                │
│  → Impossible reaction times                                │
│  → Abnormal session metrics                                 │
├─────────────────────────────────────────────────────────────┤
│  LAYER 4: Client-Side (Optional)                             │
│  → Memory scanning (EAC, BattlEye)                          │
│  → Process monitoring                                       │
└─────────────────────────────────────────────────────────────┘
```

## 🔧 Troubleshooting

```
┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Players rubber-banding / teleporting               │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Increase interpolation buffer                             │
│ → Add jitter buffer for packets                             │
│ → Smooth corrections (lerp, not snap)                       │
│ → Check prediction code determinism                         │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Desyncs between clients                            │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Use fixed-point math                                      │
│ → Sync random seeds                                         │
│ → Periodic full-state resync                                │
│ → State hash comparison                                     │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: High bandwidth usage                               │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Implement delta compression                               │
│ → Reduce tick rate for non-critical data                    │
│ → Use interest management                                   │
│ → Quantize position/rotation values                         │
└─────────────────────────────────────────────────────────────┘
```

## Framework Comparison

| Framework | Best For | Max Players | Learning Curve |
|-----------|----------|-------------|----------------|
| Photon | Quick start | 16-32 | Easy |
| Mirror | Open source | 100+ | Medium |
| Netcode for GO | Unity official | 100+ | Medium |
| FishNet | Performance | 200+ | Medium |
| Custom | Full control | Unlimited | Hard |

---

**Use this skill**: When building multiplayer, designing servers, or implementing anti-cheat.

Overview

This skill helps game developers design and implement scalable, responsive multiplayer systems focused on netcode, server architecture, synchronization, and anti-cheat. It distills production-ready patterns like authoritative servers, client prediction with reconciliation, server-side lag compensation, and bandwidth optimization. It emphasizes practical outcomes: stable gameplay, reduced cheating, and efficient use of resources.

How this skill works

The skill inspects common multiplayer subsystems and provides concrete implementation patterns: authoritative client-server flow, prediction + reconciliation on clients, server-side rewind for hit validation, and auto-scaled game server topologies. It recommends serialization and bandwidth techniques (delta compression, quantization, bit packing, interest management) and layered anti-cheat checks from server validation to statistical detection. It also offers troubleshooting guidance for rubber-banding, desyncs, and high bandwidth.

When to use it

Building real-time multiplayer games where responsiveness and fairness matter (FPS, action, racing).
Designing server infrastructure that must scale across regions and sessions.
Implementing netcode to reduce perceived latency while preventing client-side cheating.
Optimizing bandwidth and CPU use for large-scale player counts.
Troubleshooting recurrent desyncs, rubber-banding, or spiking bandwidth costs.

Best practices

Authoritative server: validate all critical game state server-side; never trust client input.
Use client prediction with reconciliation to preserve responsiveness, and replay unacked inputs after server correction.
Implement server-side rewind/lag compensation for accurate hit validation using RTT-informed rewind windows.
Apply bandwidth reductions: send deltas, quantize floats, pack bits, and limit updates via interest management.
Layer anti-cheat: sanity checks, statistical anomaly detection, and optional client-side protections for harder-to-detect threats.
Prefer deterministic subsystems (fixed-point math, synced RNG) and periodic full-state hashes to detect divergence.

Example use cases

First-person shooter: authoritative server with client prediction, reconciliation, and server-side rewind for hit checks.
Battle royale or MMO: auto-scaled regional game servers with matchmaking, interest management, and database-backed persistence.
Competitive racing game: lower tick rate for non-critical updates, high-fidelity interpolation for position smoothing.
Small-team PvP: open-source netcode frameworks (Mirror, FishNet) when time-to-market matters; custom stack for max control.
Cheat mitigation pipeline: combine server validation, rate/velocity caps, and statistical detectors to flag suspicious accounts.

FAQ

How do I choose tick rate vs bandwidth?

Balance player responsiveness and server/network capacity: raise tick rate for critical gameplay (movement, shooting) and reduce update frequency for cosmetic or non-critical data; use delta compression and interest management to lower bandwidth cost.

When should I use server-side rewind?

Use rewind for client-hit actions where latency would otherwise make hits unfair; compute rewind time from measured RTT and cap to a safe window to avoid excessive state history.