Ludo Multiplayer with Socket.IO — Room Architecture, Event Handling & Production Scaling

import { createServer } from 'http';
import { Server } from 'socket.io';
import { randomInt } from 'node:crypto';
import { LudoGameEngine } from './LudoGameEngine';
import { Player, GameRoom, MoveResult, DiceResult } from './types';

const PORT = 3001;

const httpServer = createServer();
const io = new Server(httpServer, {
  cors: {
    origin: ['https://your-ludo-app.com', 'http://localhost:3000'],
    methods: ['GET', 'POST'],
    credentials: true
  },
  pingInterval: 25000,
  pingTimeout: 20000,
  transports: ['websocket', 'polling'],
  perMessageDeflate: true
});

// In-memory game store — replace with Redis for multi-process scaling
const activeGames = new Map<string, LudoGameEngine>();
const playerSockets = new Map<string, { socketId: string; roomId: string; disconnectedAt: number }>();

const RECONNECT_GRACE_MS = 30000;
const MAX_PLAYERS_PER_ROOM = 4;

io.on('connection', (socket) => {
  console.log(`[Connect] Socket {socket.id} connected`);

  // ── Game Creation ──────────────────────────────────────────
  socket.on('game:create', ({ playerName }: { playerName: string }) => {
    const roomId = generateRoomCode();
    const playerId = generatePlayerId();

    const game = new LudoGameEngine(roomId, MAX_PLAYERS_PER_ROOM);
    game.addPlayer(playerId, playerName);
    activeGames.set(roomId, game);

    socket.join(roomId);
    socket.data = { playerId, roomId, playerIndex: 0, hasRolled: false };

    playerSockets.set(playerId, {
      socketId: socket.id,
      roomId,
      disconnectedAt: 0
    });

    socket.emit('game:created', {
      roomId,
      playerId,
      playerIndex: 0,
      shareCode: roomId
    });

    console.log(`[Game] Created room {roomId} by {playerId}`);
  });

  // ── Joining an Existing Room ────────────────────────────────
  socket.on('game:join', ({ roomId, playerName }: { roomId: string; playerName: string }) => {
    const game = activeGames.get(roomId);

    if (!game) {
      socket.emit('game:error', { code: 'ROOM_NOT_FOUND', message: 'Room does not exist' });
      return;
    }

    if (game.state.status === 'playing') {
      socket.emit('game:error', { code: 'GAME_ALREADY_STARTED', message: 'Game already in progress' });
      return;
    }

    if (game.state.players.length >= MAX_PLAYERS_PER_ROOM) {
      socket.emit('game:error', { code: 'ROOM_FULL', message: 'Room is full' });
      return;
    }

    const playerId = generatePlayerId();
    const playerIndex = game.addPlayer(playerId, playerName);

    socket.join(roomId);
    socket.data = { playerId, roomId, playerIndex, hasRolled: false };

    playerSockets.set(playerId, {
      socketId: socket.id,
      roomId,
      disconnectedAt: 0
    });

    socket.emit('game:joined', {
      roomId,
      playerId,
      playerIndex,
      playerCount: game.state.players.length
    });

    io.to(roomId).emit('player:joined', {
      playerId,
      playerIndex,
      playerName,
      playerCount: game.state.players.length
    });

    if (game.state.players.length === MAX_PLAYERS_PER_ROOM) {
      game.start();
      io.to(roomId).emit('game:start', {
        state: game.getPublicState(),
        firstPlayerIndex: game.state.currentPlayerIndex
      });
    }
  });

  // ── Dice Rolling ────────────────────────────────────────────
  socket.on('game:roll', () => {
    const { roomId, playerId, playerIndex, hasRolled } = socket.data;

    if (!roomId || !playerId) {
      socket.emit('game:error', { code: 'NOT_IN_GAME', message: 'You are not in a game room' });
      return;
    }

    const game = activeGames.get(roomId);
    if (!game) return;

    if (game.state.currentPlayerIndex !== playerIndex) {
      socket.emit('game:error', { code: 'NOT_YOUR_TURN', message: 'Wait for your turn' });
      return;
    }

    if (hasRolled) {
      socket.emit('game:error', { code: 'ALREADY_ROLLED', message: 'You have already rolled this turn' });
      return;
    }

    // Server-authoritative dice roll using crypto.randomInt()
    const diceValue = randomInt(1, 7);
    const rollResult: DiceResult = game.rollDice(playerIndex, diceValue);
    socket.data.hasRolled = true;

    // Broadcast dice result to ALL players in the room
    io.to(roomId).emit('game:dice-rolled', {
      playerIndex,
      playerId,
      value: diceValue,
      canMove: rollResult.canMove,
      eligiblePieces: rollResult.eligiblePieces
    });

    // If no eligible moves (not a 6 and all pieces locked), advance turn immediately
    if (!rollResult.canMove) {
      advanceTurn(game, roomId);
    }
  });

  // ── Piece Movement ─────────────────────────────────────────
  socket.on('game:move', ({ pieceId }: { pieceId: number }) => {
    const { roomId, playerId, playerIndex, hasRolled } = socket.data;

    const game = activeGames.get(roomId);
    if (!game) return;

    if (game.state.currentPlayerIndex !== playerIndex) {
      socket.emit('game:error', { code: 'NOT_YOUR_TURN', message: 'Not your turn' });
      return;
    }

    if (!hasRolled) {
      socket.emit('game:error', { code: 'ROLL_FIRST', message: 'Roll the dice before moving' });
      return;
    }

    const moveResult: MoveResult = game.movePiece(playerIndex, pieceId);

    if (moveResult.error) {
      socket.emit('game:error', { code: 'INVALID_MOVE', message: moveResult.error });
      return;
    }

    // Broadcast the validated move to all players
    io.to(roomId).emit('game:piece-moved', {
      playerIndex,
      pieceId,
      from: moveResult.from,
      to: moveResult.to,
      captured: moveResult.captured,
      landedOnFinish: moveResult.landedOnFinish,
      newPiecePositions: moveResult.allPiecePositions
    });

    // Check if the player earned another turn (rolled a 6)
    if (moveResult.earnsExtraTurn) {
      socket.data.hasRolled = false;
      io.to(roomId).emit('game:turn-continues', {
        playerIndex,
        playerId,
        message: 'Rolled a 6 — go again!'
      });
    } else {
      advanceTurn(game, roomId);
    }
  });

  // ── Disconnect Handling ─────────────────────────────────────
  socket.on('disconnect', (reason) => {
    console.log(`[Disconnect] Socket {socket.id} — {reason}`);
    const { playerId, roomId } = socket.data;

    if (!playerId || !roomId) return;

    const game = activeGames.get(roomId);
    if (!game) return;

    const playerData = playerSockets.get(playerId);
    if (playerData) {
      playerData.disconnectedAt = Date.now();
    }

    io.to(roomId).emit('player:disconnected', {
      playerId,
      playerIndex: socket.data.playerIndex,
      willRejoin: true,
      gracePeriodMs: RECONNECT_GRACE_MS
    });

    // After grace period, mark as permanently disconnected
    setTimeout(() => {
      const stillConnected = io.sockets.adapter.rooms.get(roomId)?.has(socket.id);
      if (!stillConnected && playerSockets.get(playerId)?.disconnectedAt > 0) {
        game.markPlayerDisconnected(socket.data.playerIndex);
        io.to(roomId).emit('player:left', {
          playerId,
          playerIndex: socket.data.playerIndex,
          replacedBy: 'bot'
        });
        playerSockets.delete(playerId);
      }
    }, RECONNECT_GRACE_MS);
  });

  // ── Reconnection ─────────────────────────────────────────────
  socket.on('game:rejoin', ({ playerId, roomId }: { playerId: string; roomId: string }) => {
    const stored = playerSockets.get(playerId);
    const game = activeGames.get(roomId);

    if (!stored || !game || stored.roomId !== roomId) {
      socket.emit('game:error', { code: 'REJOIN_FAILED', message: 'Cannot rejoin this room' });
      return;
    }

    const timeSinceDisconnect = Date.now() - stored.disconnectedAt;
    if (timeSinceDisconnect > RECONNECT_GRACE_MS) {
      socket.emit('game:error', { code: 'GRACE_PERIOD_EXPIRED', message: 'Reconnection window has closed' });
      return;
    }

    const playerIndex = game.rejoinPlayer(playerId);

    socket.join(roomId);
    socket.data = { playerId, roomId, playerIndex, hasRolled: false };
    stored.socketId = socket.id;
    stored.disconnectedAt = 0;

    const missedEvents = game.getEventsSince(stored.disconnectedAt);

    socket.emit('game:rejoined', {
      roomId,
      playerId,
      playerIndex,
      state: game.getPublicState(),
      missedEvents
    });

    io.to(roomId).emit('player:reconnected', { playerId, playerIndex });
  });
});

function advanceTurn(game: LudoGameEngine, roomId: string) {
  const nextPlayerIndex = game.nextTurn();
  io.to(roomId).emit('game:turn-change', {
    currentPlayerIndex: nextPlayerIndex,
    currentPlayerId: game.state.players[nextPlayerIndex].id,
    turnNumber: game.state.turnNumber
  });
}

function generateRoomCode(): string {
  const chars = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
  let code = '';
  for (let i = 0; i < 6; i++) {
    code += chars[randomInt(0, chars.length)];
  }
  return code;
}

function generatePlayerId(): string {
  return 'p_' + randomInt(1e15, 1e16).toString(36);
}

httpServer.listen(PORT, () => {
  console.log(`Ludo Socket.IO server listening on port {PORT}`);
});

import { io, Socket } from 'socket.io-client';
import { GameState } from './types';

type EventMap = {
  'connected': () => void;
  'disconnected': (reason: string) => void;
  'gameCreated': (data: { roomId: string; playerId: string; shareCode: string }) => void;
  'gameJoined': (data: { roomId: string; playerId: string; playerCount: number }) => void;
  'playerJoined': (data: { playerId: string; playerName: string; playerCount: number }) => void;
  'gameStart': (data: { state: GameState; firstPlayerIndex: number }) => void;
  'diceRolled': (data: { playerIndex: number; value: number; canMove: boolean; eligiblePieces: number[] }) => void;
  'pieceMoved': (data: { pieceId: number; from: number; to: number; captured: boolean; newPiecePositions: Record<number, number> }) => void;
  'turnChange': (data: { currentPlayerIndex: number; turnNumber: number }) => void;
  'gameEnded': (data: { winnerIndex: number; scores: number[] }) => void;
  'playerDisconnected': (data: { playerId: string; gracePeriodMs: number }) => void;
  'playerReconnected': (data: { playerId: string }) => void;
  'error': (data: { code: string; message: string }) => void;
};

class LudoClient {
  private socket: Socket;
  private eventListeners = new Map<keyof EventMap, Set<EventMap[keyof EventMap]>>();

  public roomId: string | null = null;
  public playerId: string | null = null;
  public playerIndex: number | null = null;
  public gameState: GameState | null = null;
  public connectionState: 'disconnected' | 'connecting' | 'connected' = 'disconnected';

  constructor(serverUrl: string = 'wss://api.ludokingapi.site') {
    this.socket = io(serverUrl + '/ludo', {
      autoConnect: true,
      reconnection: true,
      reconnectionDelay: 1000,
      reconnectionDelayMax: 8000,
      reconnectionAttempts: 10,
      timeout: 15000,
      transports: ['websocket', 'polling']
    });

    this._bindConnectionHandlers();
    this._bindGameHandlers();
  }

  private _bindConnectionHandlers(): void {
    this.socket.on('connect', () => {
      this.connectionState = 'connected';
      this._emit('connected');
    });

    this.socket.on('disconnect', (reason: string) => {
      this.connectionState = 'disconnected';
      this._emit('disconnected', reason);

      // If server initiated the disconnect, try to reconnect manually
      if (reason === 'io server disconnect') {
        this.socket.connect();
      }
    });

    this.socket.on('connect_error', (err: Error) => {
      console.error('Connection error:', err.message);
      if (err.message.includes('401')) {
        this._emit('error', { code: 'AUTH_FAILED', message: 'Authentication failed' });
      }
    });

    this.socket.on('reconnect_attempt', (attempt: number) => {
      console.log(`Reconnect attempt {attempt}`);
    });

    this.socket.on('reconnect_failed', () => {
      this._emit('error', { code: 'RECONNECT_FAILED', message: 'Could not reconnect to the game server' });
    });
  }

  private _bindGameHandlers(): void {
    this.socket.on('game:created', (data) => {
      this.roomId = data.roomId;
      this.playerId = data.playerId;
      this.playerIndex = data.playerIndex;
      this._emit('gameCreated', data);
    });

    this.socket.on('game:joined', (data) => {
      this.roomId = data.roomId;
      this.playerId = data.playerId;
      this.playerIndex = data.playerIndex;
      this._emit('gameJoined', data);
    });

    this.socket.on('player:joined', (data) => {
      this._emit('playerJoined', data);
    });

    this.socket.on('game:start', (data) => {
      this.gameState = data.state;
      this._emit('gameStart', data);
    });

    this.socket.on('game:dice-rolled', (data) => {
      this._emit('diceRolled', data);
    });

    this.socket.on('game:piece-moved', (data) => {
      this._emit('pieceMoved', data);
    });

    this.socket.on('game:turn-change', (data) => {
      this._emit('turnChange', data);
    });

    this.socket.on('game:ended', (data) => {
      this._emit('gameEnded', data);
    });

    this.socket.on('player:disconnected', (data) => {
      this._emit('playerDisconnected', data);
    });

    this.socket.on('player:reconnected', (data) => {
      this._emit('playerReconnected', data);
    });

    this.socket.on('game:error', (data) => {
      this._emit('error', data);
    });
  }

  // ── Public API ──────────────────────────────────────────────

  connect(): void {
    this.connectionState = 'connecting';
    this.socket.connect();
  }

  createRoom(playerName: string): void {
    this.socket.emit('game:create', { playerName });
  }

  joinRoom(roomId: string, playerName: string): void {
    this.socket.emit('game:join', { roomId, playerName });
  }

  rejoinGame(playerId: string, roomId: string): void {
    this.socket.emit('game:rejoin', { playerId, roomId });
  }

  rollDice(): void {
    this.socket.emit('game:roll');
  }

  movePiece(pieceId: number): void {
    this.socket.emit('game:move', { pieceId });
  }

  disconnect(): void {
    this.socket.disconnect();
  }

  // ── Event Subscription ─────────────────────────────────────

  on<K extends keyof EventMap>(
    event: K,
    callback: EventMap[K]
  ): void {
    if (!this.eventListeners.has(event)) {
      this.eventListeners.set(event, new Set());
    }
    this.eventListeners.get(event).add(callback);
  }

  off<K extends keyof EventMap>(
    event: K,
    callback: EventMap[K]
  ): void {
    this.eventListeners.get(event)?.delete(callback);
  }

  private _emit<K extends keyof EventMap>(
    event: K,
    data?: Parameters<EventMap[K]>[0]
  ): void {
    const listeners = this.eventListeners.get(event);
    if (listeners) {
      listeners.forEach((cb) => cb(data));
    }
  }
}

export { LudoClient };

import { createServer } from 'http';
import { Server } from 'socket.io';
import { createAdapter } from '@socket.io/redis-adapter';
import { createClient } from 'redis';

const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
const PORT = 3001;

async function bootstrap() {
  // Create two Redis clients — one for publishing, one for subscribing
  const pubClient = createClient({ url: REDIS_URL });
  const subClient = createClient({ url: REDIS_URL });

  await Promise.all([pubClient.connect(), subClient.connect()]);

  const httpServer = createServer();
  const io = new Server(httpServer, {
    cors: { origin: '*', methods: ['GET', 'POST'] },
    transports: ['websocket', 'polling']
  });

  // Attach Redis adapter — this replaces the default in-memory adapter
  io.adapter(createAdapter(pubClient, subClient));

  // Server ID for debugging which instance handles which socket
  const serverId = `server-${process.pid}`;

  io.on('connection', (socket) => {
    socket.on('game:join', ({ roomId }) => {
      socket.join(roomId);
      console.log(`[{serverId}] Player {socket.id} joined room {roomId}`);
      io.to(roomId).emit('room:count', {
        roomId,
        count: io.adapter.rooms.get(roomId)?.size ?? 0
      });
    });

    socket.on('game:roll', ({ roomId }) => {
      const result = Math.floor(Math.random() * 6) + 1;
      // Redis adapter fans out to all processes — all players receive this
      io.to(roomId).emit('game:dice-result', { value: result });
    });
  });

  httpServer.listen(PORT, () => {
    console.log(`Scaled Ludo server running on :{PORT} ({serverId})`);
  });
}

bootstrap();