Multiplayer State Synchronization & Replication

## ROLE
You are a game networking engineer specializing in state replication and synchronization. You design systems that efficiently transmit game state across the network while minimizing bandwidth, maintaining consistency, and handling the challenges of unreliable networks.

## OBJECTIVE
Design a state synchronization system that keeps all players' game views consistent with the server while operating within strict bandwidth budgets and handling packet loss gracefully.

## TASK
Create a comprehensive state synchronization design:

### Replication Architecture

**1. Entity Replication Model**
- Which entities are replicated (players, NPCs, projectiles, items, environment)
- Replication frequency per entity type
- Owner vs. observer replication (different detail levels)
- Authority model (who can modify each entity)
- Entity creation and destruction replication

**2. Property Replication**
For each entity type, define:
- Replicated properties (position, rotation, health, state)
- Non-replicated properties (local VFX state, audio triggers)
- Replication conditions (only when changed, always, conditional)
- Replication priority (critical vs. cosmetic)
- Quantization level (precision vs. bandwidth trade-off)

**3. Replication Modes**
```
Reliable Ordered: Inventory changes, chat, scoring events
  - Guaranteed delivery in order
  - Higher latency on packet loss (waits for resend)

Reliable Unordered: Object spawning, state changes
  - Guaranteed delivery, order not guaranteed
  - Better latency on loss than reliable ordered

Unreliable: Position updates, rotation, animations
  - Best-effort delivery
  - Latest state always supersedes older state
  - Lost packets are simply skipped (newer data coming)
```

### Bandwidth Optimization

**1. Quantization**
- Position: Float32 vs. Float16 vs. fixed-point (precision needs vary)
- Rotation: Quaternion compression (smallest-three method saves 25%)
- Velocity: Relative to maximum speed (normalized)
- Health/stats: Integer precision
- Angles: Packed bytes (256 values for 360 degrees)
- Boolean packing: 8 booleans in 1 byte

**2. Delta Compression**
- Only send properties that changed since last acknowledged update
- Bitfield indicating which properties are in the packet
- Property-level delta (new position = old position + delta)
- Baseline synchronization for delta reference points
- Handling missed baselines

**3. Prioritization System**
```
Each entity gets a priority score:
Priority = base_priority * distance_factor * relevance_factor * time_since_update

- Close entities: High priority, frequent updates
- Far entities: Low priority, infrequent updates
- Entities in view: Boosted priority
- Entities interacting with player: Maximum priority
- Newly spawned entities: Temporary priority boost
```

**4. Interest Management**
- Area of Interest (AOI): Only replicate entities within range
- AOI shapes: Circle, sector (view cone), grid cells
- Dynamic AOI sizing based on entity speed and type
- Hysteresis: Larger exit radius than entry radius (prevents flickering)
- Override interest for important entities (party members, objectives)

### Snapshot System

**1. Snapshot Generation**
- Full snapshot: Complete game state (used for initial sync and desync recovery)
- Delta snapshot: Changes since client's last acknowledged snapshot
- Snapshot rate: Typically matches server tick rate
- Snapshot buffering on client (for interpolation)

**2. Snapshot Delivery**
- Snapshot sequencing and ordering
- Handling out-of-order delivery
- Snapshot acknowledgment from clients
- Snapshot retransmission on loss
- Adaptive snapshot rate based on bandwidth

**3. Client-Side Processing**
```
Snapshot arrives on client:
1. Check sequence number (discard if older than current)
2. Decompress and deserialize
3. Add to interpolation buffer
4. Interpolate between two snapshots for rendering
5. Send acknowledgment to server
```

### Consistency Guarantees

**Eventual Consistency Areas:**
- Player positions (converge quickly, brief visual errors acceptable)
- Animation states (visual-only, low impact)
- Particle effects and VFX

**Strong Consistency Areas:**
- Health and damage events
- Scoring and objectives
- Inventory and economy
- Game mode state (round start, end, transitions)
- These MUST use reliable delivery

### Edge Cases
- Teleportation handling (do not interpolate through walls)
- Rapid direction changes (overshoot prevention)
- Entity ownership transfer mid-match
- Late-joining player synchronization (full state dump)
- Reconnection after disconnect (state recovery)
- Spectator state management

### Debugging
- State diff visualization
- Bandwidth usage breakdown per entity type
- Replication frequency histograms
- Priority score visualization
- Network condition simulation tools