♔ Chess Online - Real-Time Multiplayer ♚

// server.js - Socket.io server setup
const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const Redis = require('ioredis');

const app = express();
const server = http.createServer(app);
const io = socketIo(server, {
  cors: {
    origin: process.env.CLIENT_URL,
    methods: ['GET', 'POST']
  },
  pingTimeout: 60000,
  pingInterval: 25000
});

// Redis pub/sub for multi-server scaling
const redisPublisher = new Redis(process.env.REDIS_URL);
const redisSubscriber = new Redis(process.env.REDIS_URL);

// Subscribe to game events from other servers
redisSubscriber.subscribe('chess:games');
redisSubscriber.on('message', (channel, message) => {
  const event = JSON.parse(message);
  io.to(event.gameId).emit(event.type, event.data);
});

// Connection management
const activeConnections = new Map();

io.on('connection', (socket) => {
  console.log(`New connection: ${socket.id}`);
  
  // Authentication
  const token = socket.handshake.auth.token;
  const user = verifyToken(token);
  
  if (!user) {
    socket.disconnect();
    return;
  }
  
  socket.userId = user.id;
  activeConnections.set(socket.id, { userId: user.id, socketId: socket.id });
  
  // Join user's personal room
  socket.join(`user:${user.id}`);
  
  // Handle game events
  require('./handlers/gameHandlers')(io, socket, redisPublisher);
  require('./handlers/chatHandlers')(io, socket);
  require('./handlers/matchmakingHandlers')(io, socket);
  
  socket.on('disconnect', () => {
    handleDisconnection(socket);
    activeConnections.delete(socket.id);
  });
});

server.listen(3000, () => {
  console.log('Chess server running on port 3000');
});

// handlers/gameHandlers.js - Game event handling
const Chess = require('chess.js').Chess;
const GameModel = require('../models/Game');

module.exports = (io, socket, redisPublisher) => {
  
  // Join game room
  socket.on('game:join', async (gameId) => {
    try {
      const game = await GameModel.findById(gameId);
      
      if (!game) {
        return socket.emit('error', { message: 'Game not found' });
      }
      
      // Check if user is player or spectator
      const isPlayer = game.white.equals(socket.userId) || 
                       game.black.equals(socket.userId);
      
      socket.join(`game:${gameId}`);
      
      if (isPlayer) {
        socket.join(`game:${gameId}:players`);
      } else {
        socket.join(`game:${gameId}:spectators`);
      }
      
      // Send current game state
      socket.emit('game:state', {
        fen: game.fen,
        moves: game.moves,
        status: game.status,
        turn: game.turn,
        whiteTime: game.whiteTime,
        blackTime: game.blackTime
      });
      
      // Notify others
      socket.to(`game:${gameId}`).emit('player:joined', {
        userId: socket.userId,
        isSpectator: !isPlayer
      });
      
    } catch (error) {
      socket.emit('error', { message: 'Failed to join game' });
    }
  });
  
  // Handle move
  socket.on('game:move', async ({ gameId, move }) => {
    try {
      const game = await GameModel.findById(gameId);
      
      if (!game) {
        return socket.emit('error', { message: 'Game not found' });
      }
      
      // Verify it's player's turn
      const isWhite = game.white.equals(socket.userId);
      const isBlack = game.black.equals(socket.userId);
      
      if ((game.turn === 'w' && !isWhite) || (game.turn === 'b' && !isBlack)) {
        return socket.emit('error', { message: 'Not your turn' });
      }
      
      // Validate and apply move
      const chess = new Chess(game.fen);
      const result = chess.move(move);
      
      if (!result) {
        return socket.emit('error', { message: 'Invalid move' });
      }
      
      // Update game state
      game.fen = chess.fen();
      game.moves.push({
        from: result.from,
        to: result.to,
        piece: result.piece,
        san: result.san,
        timestamp: new Date()
      });
      game.turn = chess.turn();
      
      // Check for game over
      if (chess.isCheckmate()) {
        game.status = 'checkmate';
        game.winner = game.turn === 'w' ? game.black : game.white;
      } else if (chess.isDraw()) {
        game.status = 'draw';
      } else if (chess.isStalemate()) {
        game.status = 'stalemate';
      }
      
      await game.save();
      
      // Broadcast move to all players and spectators
      const moveData = {
        gameId,
        move: result,
        fen: chess.fen(),
        turn: chess.turn(),
        status: game.status,
        isCheck: chess.inCheck(),
        isCheckmate: chess.isCheckmate(),
        isDraw: chess.isDraw()
      };
      
      io.to(`game:${gameId}`).emit('game:move', moveData);
      
      // Publish to Redis for other server instances
      redisPublisher.publish('chess:games', JSON.stringify({
        type: 'game:move',
        gameId,
        data: moveData
      }));
      
    } catch (error) {
      socket.emit('error', { message: 'Failed to process move' });
    }
  });
  
  // Handle resignation
  socket.on('game:resign', async (gameId) => {
    const game = await GameModel.findById(gameId);
    
    if (!game) return;
    
    game.status = 'resigned';
    game.winner = game.white.equals(socket.userId) ? game.black : game.white;
    await game.save();
    
    io.to(`game:${gameId}`).emit('game:ended', {
      status: 'resigned',
      winner: game.winner
    });
  });
  
  // Handle draw offer
  socket.on('game:offer-draw', async (gameId) => {
    socket.to(`game:${gameId}:players`).emit('game:draw-offered', {
      from: socket.userId
    });
  });
  
  socket.on('game:accept-draw', async (gameId) => {
    const game = await GameModel.findById(gameId);
    game.status = 'draw-agreed';
    await game.save();
    
    io.to(`game:${gameId}`).emit('game:ended', {
      status: 'draw-agreed'
    });
  });
};

// hooks/useSocket.ts - React hook for Socket.io
import { useEffect, useRef, useState } from 'react';
import io, { Socket } from 'socket.io-client';

interface UseSocketReturn {
  socket: Socket | null;
  connected: boolean;
  joinGame: (gameId: string) => void;
  makeMove: (move: any) => void;
  resign: () => void;
  offerDraw: () => void;
}

export const useSocket = (token: string): UseSocketReturn => {
  const socketRef = useRef(null);
  const [connected, setConnected] = useState(false);
  const [currentGameId, setCurrentGameId] = useState(null);
  
  useEffect(() => {
    // Initialize socket connection
    socketRef.current = io(process.env.REACT_APP_SERVER_URL!, {
      auth: { token },
      reconnection: true,
      reconnectionDelay: 1000,
      reconnectionDelayMax: 5000,
      reconnectionAttempts: 5
    });
    
    const socket = socketRef.current;
    
    // Connection events
    socket.on('connect', () => {
      console.log('Connected to server');
      setConnected(true);
      
      // Rejoin game if was in one
      if (currentGameId) {
        socket.emit('game:join', currentGameId);
      }
    });
    
    socket.on('disconnect', () => {
      console.log('Disconnected from server');
      setConnected(false);
    });
    
    socket.on('connect_error', (error) => {
      console.error('Connection error:', error);
    });
    
    // Cleanup on unmount
    return () => {
      socket.disconnect();
    };
  }, [token]);
  
  const joinGame = (gameId: string) => {
    if (socketRef.current) {
      socketRef.current.emit('game:join', gameId);
      setCurrentGameId(gameId);
    }
  };
  
  const makeMove = (move: any) => {
    if (socketRef.current && currentGameId) {
      socketRef.current.emit('game:move', {
        gameId: currentGameId,
        move
      });
    }
  };
  
  const resign = () => {
    if (socketRef.current && currentGameId) {
      socketRef.current.emit('game:resign', currentGameId);
    }
  };
  
  const offerDraw = () => {
    if (socketRef.current && currentGameId) {
      socketRef.current.emit('game:offer-draw', currentGameId);
    }
  };
  
  return {
    socket: socketRef.current,
    connected,
    joinGame,
    makeMove,
    resign,
    offerDraw
  };
};

// engine/moveValidator.js - Chess move validation
const Chess = require('chess.js').Chess;

class MoveValidator {
  constructor() {
    this.chess = new Chess();
  }
  
  // Load position from FEN
  loadPosition(fen) {
    return this.chess.load(fen);
  }
  
  // Validate and execute move
  validateMove(move) {
    try {
      // chess.js accepts moves in various formats:
      // - SAN: 'Nxf3', 'e4', 'O-O'
      // - Object: { from: 'e2', to: 'e4' }
      const result = this.chess.move(move);
      
      if (!result) {
        return { valid: false, error: 'Invalid move' };
      }
      
      return {
        valid: true,
        move: result,
        fen: this.chess.fen(),
        turn: this.chess.turn(),
        gameOver: this.chess.isGameOver(),
        inCheck: this.chess.inCheck(),
        inCheckmate: this.chess.isCheckmate(),
        inStalemate: this.chess.isStalemate(),
        inDraw: this.chess.isDraw(),
        inThreefoldRepetition: this.chess.inThreefoldRepetition(),
        insufficientMaterial: this.chess.insufficientMaterial()
      };
    } catch (error) {
      return { valid: false, error: error.message };
    }
  }
  
  // Get all legal moves
  getLegalMoves(square = null) {
    if (square) {
      return this.chess.moves({ square, verbose: true });
    }
    return this.chess.moves({ verbose: true });
  }
  
  // Get piece at square
  getPiece(square) {
    return this.chess.get(square);
  }
  
  // Check if square is attacked
  isAttacked(square, color) {
    return this.chess.isAttacked(square, color);
  }
  
  // Get game history
  getHistory() {
    return this.chess.history({ verbose: true });
  }
  
  // Undo last move
  undo() {
    return this.chess.undo();
  }
  
  // Export to PGN
  exportPGN(headers = {}) {
    this.chess.header(
      'Event', headers.event || 'Casual Game',
      'Site', headers.site || 'Chess Online',
      'Date', new Date().toISOString().split('T')[0],
      'White', headers.white || 'Player 1',
      'Black', headers.black || 'Player 2'
    );
    
    return this.chess.pgn();
  }
  
  // Get position evaluation (basic)
  evaluatePosition() {
    const board = this.chess.board();
    let evaluation = 0;
    
    const pieceValues = {
      'p': 1, 'n': 3, 'b': 3, 'r': 5, 'q': 9, 'k': 0
    };
    
    for (let row of board) {
      for (let square of row) {
        if (square) {
          const value = pieceValues[square.type];
          evaluation += square.color === 'w' ? value : -value;
        }
      }
    }
    
    return evaluation;
  }
}

module.exports = MoveValidator;

// engine/gameState.js - Game state management
class GameState {
  constructor(gameId, white, black, timeControl) {
    this.gameId = gameId;
    this.white = white;
    this.black = black;
    this.fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1';
    this.moves = [];
    this.status = 'active';
    this.turn = 'w';
    this.timeControl = timeControl; // e.g., { time: 300, increment: 2 }
    this.whiteTime = timeControl.time * 1000; // milliseconds
    this.blackTime = timeControl.time * 1000;
    this.lastMoveTime = Date.now();
    this.drawOffered = null;
  }
  
  // Update time after move
  updateTime() {
    const now = Date.now();
    const elapsed = now - this.lastMoveTime;
    
    if (this.turn === 'w') {
      this.blackTime -= elapsed;
      this.blackTime += this.timeControl.increment * 1000;
    } else {
      this.whiteTime -= elapsed;
      this.whiteTime += this.timeControl.increment * 1000;
    }
    
    this.lastMoveTime = now;
    
    // Check for time out
    if (this.whiteTime <= 0) {
      this.status = 'timeout';
      this.winner = this.black;
      return 'white-timeout';
    } else if (this.blackTime <= 0) {
      this.status = 'timeout';
      this.winner = this.white;
      return 'black-timeout';
    }
    
    return null;
  }
  
  // Add move to history
  addMove(move) {
    this.moves.push({
      ...move,
      timestamp: new Date(),
      timeLeft: this.turn === 'w' ? this.whiteTime : this.blackTime
    });
  }
  
  // Get move in algebraic notation
  getMoveNotation(moveNumber) {
    if (moveNumber >= this.moves.length) return null;
    
    const move = this.moves[moveNumber];
    return `${Math.floor(moveNumber / 2) + 1}${moveNumber % 2 === 0 ? '.' : '...'} ${move.san}`;
  }
  
  // Export full game notation
  getFullNotation() {
    let notation = '';
    for (let i = 0; i < this.moves.length; i += 2) {
      const moveNum = Math.floor(i / 2) + 1;
      notation += `${moveNum}. ${this.moves[i].san}`;
      if (i + 1 < this.moves.length) {
        notation += ` ${this.moves[i + 1].san}`;
      }
      notation += ' ';
    }
    return notation.trim();
  }
  
  // Serialize for storage
  toJSON() {
    return {
      gameId: this.gameId,
      white: this.white,
      black: this.black,
      fen: this.fen,
      moves: this.moves,
      status: this.status,
      turn: this.turn,
      timeControl: this.timeControl,
      whiteTime: this.whiteTime,
      blackTime: this.blackTime,
      winner: this.winner,
      drawOffered: this.drawOffered
    };
  }
  
  // Restore from JSON
  static fromJSON(data) {
    const game = new GameState(data.gameId, data.white, data.black, data.timeControl);
    Object.assign(game, data);
    return game;
  }
}

module.exports = GameState;

// services/matchmaking.js - ELO-based matchmaking
class Matchmaking {
  constructor() {
    this.queue = new Map(); // timeControl -> players[]
  }
  
  // Add player to queue
  addToQueue(player) {
    const key = this.getTimeControlKey(player.timeControl);
    
    if (!this.queue.has(key)) {
      this.queue.set(key, []);
    }
    
    const queue = this.queue.get(key);
    queue.push({
      userId: player.userId,
      socketId: player.socketId,
      rating: player.rating,
      joinedAt: Date.now()
    });
    
    // Try to find match
    return this.findMatch(key);
  }
  
  // Remove player from queue
  removeFromQueue(userId) {
    for (const [key, queue] of this.queue.entries()) {
      const index = queue.findIndex(p => p.userId === userId);
      if (index !== -1) {
        queue.splice(index, 1);
        return true;
      }
    }
    return false;
  }
  
  // Find match based on ELO rating
  findMatch(timeControlKey) {
    const queue = this.queue.get(timeControlKey);
    
    if (queue.length < 2) {
      return null;
    }
    
    // Sort by join time
    queue.sort((a, b) => a.joinedAt - b.joinedAt);
    
    // Find best match for first player in queue
    const player1 = queue[0];
    let bestMatch = null;
    let bestRatingDiff = Infinity;
    
    // Widen search range based on wait time
    const waitTime = Date.now() - player1.joinedAt;
    const ratingRange = Math.min(400, 100 + (waitTime / 1000) * 10);
    
    for (let i = 1; i < queue.length; i++) {
      const player2 = queue[i];
      const ratingDiff = Math.abs(player1.rating - player2.rating);
      
      if (ratingDiff <= ratingRange && ratingDiff < bestRatingDiff) {
        bestMatch = player2;
        bestRatingDiff = ratingDiff;
      }
    }
    
    if (bestMatch) {
      // Remove both players from queue
      queue.splice(0, 1); // Remove player1
      const matchIndex = queue.findIndex(p => p.userId === bestMatch.userId);
      queue.splice(matchIndex, 1);
      
      return { player1, player2: bestMatch };
    }
    
    return null;
  }
  
  // Get time control key
  getTimeControlKey(timeControl) {
    return `${timeControl.time}_${timeControl.increment}`;
  }
  
  // Get queue status
  getQueueStatus() {
    const status = {};
    for (const [key, queue] of this.queue.entries()) {
      status[key] = queue.length;
    }
    return status;
  }
}

module.exports = new Matchmaking();

# Dockerfile
FROM node:18-alpine

WORKDIR /app

# Install dependencies
COPY package*.json ./
RUN npm ci --only=production

# Copy application code
COPY . .

# Build frontend
RUN npm run build

# Expose port
EXPOSE 3000

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node healthcheck.js

# Start server
CMD ["node", "server.js"]

# docker-compose.yml
version: '3.8'

services:
  chess-app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - MONGODB_URI=mongodb://mongo:27017/chess
      - REDIS_URL=redis://redis:6379
      - JWT_SECRET=${JWT_SECRET}
    depends_on:
      - mongo
      - redis
    restart: unless-stopped
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
      restart_policy:
        condition: on-failure

  mongo:
    image: mongo:6
    volumes:
      - mongo-data:/data/db
    environment:
      - MONGO_INITDB_DATABASE=chess
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes
    restart: unless-stopped

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - chess-app
    restart: unless-stopped

volumes:
  mongo-data:
  redis-data:

# nginx.conf
upstream chess_backend {
    least_conn;
    server chess-app-1:3000;
    server chess-app-2:3000;
    server chess-app-3:3000;
}

map $http_upgrade $connection_upgrade {
    default upgrade;
    '' close;
}

server {
    listen 80;
    server_name chess-online.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name chess-online.com;

    ssl_certificate /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;

    # WebSocket support
    location /socket.io/ {
        proxy_pass http://chess_backend;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        # Timeout settings
        proxy_connect_timeout 7d;
        proxy_send_timeout 7d;
        proxy_read_timeout 7d;
    }

    # API endpoints
    location /api/ {
        proxy_pass http://chess_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # Static files
    location / {
        root /usr/share/nginx/html;
        try_files $uri $uri/ /index.html;
    }
}

# .env.production
NODE_ENV=production
PORT=3000

# Database
MONGODB_URI=mongodb://username:password@cluster.mongodb.net/chess?retryWrites=true&w=majority
REDIS_URL=redis://redis-server:6379

# Authentication
JWT_SECRET=your_super_secret_jwt_key_here
JWT_EXPIRATION=7d

# CORS
CLIENT_URL=https://chess-online.com
ALLOWED_ORIGINS=https://chess-online.com,https://www.chess-online.com

# WebSocket
SOCKET_PING_TIMEOUT=60000
SOCKET_PING_INTERVAL=25000

# Rate Limiting
RATE_LIMIT_WINDOW=900000
RATE_LIMIT_MAX_REQUESTS=100

# Monitoring
SENTRY_DSN=your_sentry_dsn_here
LOG_LEVEL=info