networking-servers
Compare original and translation side by side
🇺🇸
Original
English🇨🇳
Translation
ChineseNetworking & 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│
└─────────────────────────────────────────────────────────────┘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);
}
}
}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);
}
}
}
}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 │ │
│ └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘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 |
| 技术方案 | 带宽节省比例 | 实现方式 |
|---|---|---|
| Delta Compression | 60-80% | 仅发送变更的数据 |
| Quantization | 50-70% | 浮点型→定点型转换 |
| Bit Packing | 30-50% | 自定义序列化 |
| Interest Management | 70-90% | 仅发送相关数据 |
| Priority Queue | 可变 | 非关键数据降低发送频率 |
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 │
└─────────────────────────────────────────────────────────────┘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 │
└─────────────────────────────────────────────────────────────┘┌─────────────────────────────────────────────────────────────┐
│ 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.
| 框架 | 适用场景 | 最大支持玩家数 | 学习曲线 |
|---|---|---|---|
| Photon | 快速上手开发 | 16-32 | 简单 |
| Mirror | 开源项目 | 100+ | 中等 |
| Netcode for GO | Unity官方推荐 | 100+ | 中等 |
| FishNet | 高性能需求 | 200+ | 中等 |
| Custom | 完全自定义控制 | 无限制 | 困难 |
使用场景：开发多人游戏、设计游戏服务器或实现反作弊系统时使用本技术。