pluginagentmarketplace/custom-plugin-game-developer75 installs
networking-servers
Multiplayer systems, netcode, game servers, synchronization, and anti-cheat. Build scalable, responsive multiplayer experiences.
How do I install this agent skill?
npx skills add https://github.com/pluginagentmarketplace/custom-plugin-game-developer --skill networking-serversIs this agent skill safe to install?
- Gen Agent Trust Hubpass
The skill is a comprehensive educational resource for implementing game networking, multiplayer systems, and anti-cheat mechanisms. It contains documentation, architectural diagrams, reference code in C#, and a simple local Python utility for configuration analysis. No security issues were detected.
- Socketpass
No alerts
- Snykpass
Risk: LOW · No issues
- Runlayerpass
4 files scanned · No issues
What does this agent skill do?
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
// ✅ 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
// ✅ 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.
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/pluginagentmarketplace/custom-plugin-game-developer/networking-servers">View networking-servers on skillZs</a>