# Networking

> Game networking protocols, WebSocket/UDP implementation, latency optimization for real-time multiplayer

- Skill: `majiayu000/networking-2` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/networking-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/networking-2/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/networking-2

---


# Game Networking

Implement **real-time multiplayer networking** with WebSocket, UDP, and latency optimization.

## WebSocket Game Server

```javascript
const WebSocket = require('ws');

class GameServer {
  constructor(port = 8080) {
    this.wss = new WebSocket.Server({ port });
    this.players = new Map();
    this.setupHandlers();
  }

  setupHandlers() {
    this.wss.on('connection', (ws, req) => {
      const playerId = this.generateId();
      const player = { ws, state: {}, joinedAt: Date.now() };
      this.players.set(playerId, player);

      ws.on('message', (data) => this.handleMessage(playerId, data));
      ws.on('close', () => this.handleDisconnect(playerId));
      ws.on('error', (err) => this.handleError(playerId, err));

      this.sendToPlayer(playerId, { type: 'connected', playerId });
    });
  }

  handleMessage(playerId, data) {
    try {
      const msg = JSON.parse(data);
      // Validate message structure
      if (!msg.type) throw new Error('Missing message type');
      this.processGameMessage(playerId, msg);
    } catch (err) {
      console.error(`Invalid message from ${playerId}:`, err.message);
    }
  }

  broadcast(msg, exclude = null) {
    const data = JSON.stringify(msg);
    this.players.forEach((player, id) => {
      if (id !== exclude && player.ws.readyState === WebSocket.OPEN) {
        player.ws.send(data);
      }
    });
  }
}
```

## UDP for Low Latency

```javascript
const dgram = require('dgram');

class UDPGameServer {
  constructor(port = 7777) {
    this.socket = dgram.createSocket('udp4');
    this.clients = new Map(); // address:port -> client
    this.sequence = 0;

    this.socket.on('message', (msg, rinfo) => {
      const key = `${rinfo.address}:${rinfo.port}`;
      this.handlePacket(key, msg, rinfo);
    });

    this.socket.bind(port);
  }

  send(client, data, reliable = false) {
    const packet = this.createPacket(data, reliable);
    this.socket.send(packet, client.port, client.address);
  }

  createPacket(data, reliable) {
    const seq = this.sequence++;
    const header = Buffer.alloc(4);
    header.writeUInt16LE(seq, 0);
    header.writeUInt8(reliable ? 1 : 0, 2);
    return Buffer.concat([header, data]);
  }
}
```

## Protocol Selection Guide

| Protocol | Latency | Reliability | Use Case |
|----------|---------|-------------|----------|
| WebSocket | 20-50ms | High | Web games, chat |
| UDP | 5-20ms | None | FPS, racing |
| QUIC | 10-30ms | Configurable | Modern hybrid |
| TCP | 30-100ms | High | Turn-based, MMO |

## Troubleshooting

### Common Failure Modes

| Error | Root Cause | Solution |
|-------|------------|----------|
| ECONNRESET | Client disconnect | Graceful handling |
| High latency | Network congestion | Enable delta compression |
| Packet loss | UDP unreliability | Add reliability layer |
| WebSocket timeout | Idle connection | Implement heartbeat |

### Debug Checklist

```bash
# Check active connections
netstat -an | grep :8080 | wc -l

# Monitor bandwidth
iftop -i eth0 -f "port 8080"

# Capture packets
tcpdump -i eth0 port 8080 -w capture.pcap
```

## Unit Test Template

```javascript
describe('GameServer', () => {
  let server, client;

  beforeEach(() => {
    server = new GameServer(8081);
    client = new WebSocket('ws://localhost:8081');
  });

  afterEach(() => {
    client.close();
    server.close();
  });

  test('accepts connections', (done) => {
    client.on('open', () => {
      expect(server.players.size).toBe(1);
      done();
    });
  });

  test('broadcasts messages', (done) => {
    client.on('message', (data) => {
      const msg = JSON.parse(data);
      expect(msg.type).toBe('connected');
      done();
    });
  });
});
```

## Resources

- `assets/` - Server templates
- `scripts/` - Network testing tools
- `references/` - Protocol guides