Game Networking

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

WebSocket Game Server

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

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

# 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

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