Get the FREE Ultimate OpenClaw Setup Guide →

multiplayer

Scanned
npx machina-cli add skill vudovn/antigravity-kit/multiplayer --openclaw
Files (1)
SKILL.md
2.7 KB

Multiplayer Game Development

Networking architecture and synchronization principles.


1. Architecture Selection

Decision Tree

What type of multiplayer?
│
├── Competitive / Real-time
│   └── Dedicated Server (authoritative)
│
├── Cooperative / Casual
│   └── Host-based (one player is server)
│
├── Turn-based
│   └── Client-server (simple)
│
└── Massive (MMO)
    └── Distributed servers

Comparison

ArchitectureLatencyCostSecurity
DedicatedLowHighStrong
P2PVariableLowWeak
Host-basedMediumLowMedium

2. Synchronization Principles

State vs Input

ApproachSync WhatBest For
State SyncGame stateSimple, few objects
Input SyncPlayer inputsAction games
HybridBothMost games

Lag Compensation

TechniquePurpose
PredictionClient predicts server
InterpolationSmooth remote players
ReconciliationFix mispredictions
Lag compensationRewind for hit detection

3. Network Optimization

Bandwidth Reduction

TechniqueSavings
Delta compressionSend only changes
QuantizationReduce precision
PriorityImportant data first
Area of interestOnly nearby entities

Update Rates

TypeRate
Position20-60 Hz
HealthOn change
InventoryOn change
ChatOn send

4. Security Principles

Server Authority

Client: "I hit the enemy"
Server: Validate → did projectile actually hit?
         → was player in valid state?
         → was timing possible?

Anti-Cheat

CheatPrevention
Speed hackServer validates movement
AimbotServer validates sight line
Item dupeServer owns inventory
Wall hackDon't send hidden data

5. Matchmaking

Considerations

FactorImpact
SkillFair matches
LatencyPlayable connection
Wait timePlayer patience
Party sizeGroup play

6. Anti-Patterns

❌ Don't✅ Do
Trust the clientServer is authority
Send everythingSend only necessary
Ignore latencyDesign for 100-200ms
Sync exact positionsInterpolate/predict

Remember: Never trust the client. The server is the source of truth.

Source

git clone https://github.com/vudovn/antigravity-kit/blob/main/.agent/skills/game-development/multiplayer/SKILL.mdView on GitHub

Overview

This skill covers how to architect multiplayer games, how to synchronize state across clients, and how to optimize network usage while guarding against cheating. It guides choosing between dedicated servers, host-based, client-server, or distributed architectures, and outlines practical patterns for latency, security, and matchmaking.

How This Skill Works

The skill guides you through selecting an architecture via a decision tree, then applying synchronization models (state, input, or hybrid) and lag compensation techniques. It also covers bandwidth reduction, update rate strategies, and security practices like server validation and anti-cheat. Finally, it highlights practical anti-patterns to avoid and how to tailor matchmaking for latency and fairness.

When to Use It

  • Building a real-time competitive game requiring low latency and a centralized authoritative server.
  • Creating a cooperative game with one player acting as server (host-based) to simplify hosting.
  • Developing a turn-based title where a simple client-server model suffices.
  • Scaling a game into MMO with distributed servers for scalability.
  • Need to implement robust security and anti-cheat while optimizing bandwidth.

Quick Start

  1. Step 1: Define the game type (competitive, cooperative, turn-based, or MMO) and choose an architecture (dedicated, host-based, client-server, or distributed).
  2. Step 2: Select a synchronization strategy (state, input, or hybrid) and implement lag compensation techniques.
  3. Step 3: Apply bandwidth optimizations, establish server authority, and set up matchmaking and anti-cheat controls.

Best Practices

  • Choose an authoritative server model and validate critical actions on the server.
  • Prefer state or hybrid synchronization with lag compensation.
  • Use delta compression, quantization, and area of interest to reduce bandwidth.
  • Design for latency tolerance and interpolate/predict to smooth motion.
  • Implement server-controlled logic and anti-cheat checks (server owns inventory, validates hits).

Example Use Cases

  • Competitive shooter with a dedicated, authoritative server.
  • Co-op game using host-based hosting to simplify session management.
  • Turn-based strategy using a lightweight client-server model.
  • MMO with distributed servers for load balancing and scalability.
  • Anti-cheat implementation where the server validates movement, hits, and inventory.

Frequently Asked Questions

Add this skill to your agents
Sponsor this space

Reach thousands of developers