update play with computer feature

Author: rudraprasaaad

backend/.eslintrc.js

@@ -0,0 +1,7 @@
+module.exports = {
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    project: "./tsconfig.json",
+    tsconfigRootDir: __dirname,
+  },
+};

backend/package.json

@@ -33,6 +33,7 @@
     "passport": "^0.7.0",
     "passport-google-oauth20": "^2.0.0",
     "redis": "^5.6.0",
+    "stockfish": "^17.1.0",
     "swagger-jsdoc": "^6.2.8",
     "swagger-ui-express": "^5.0.1",
     "ts-node": "^10.9.2",

backend/prisma/migrations/20250915212118_bot_enum/migration.sql

@@ -0,0 +1,2 @@
+-- AlterEnum
+ALTER TYPE "public"."RoomType" ADD VALUE 'BOT';

backend/prisma/schema.prisma

@@ -108,6 +108,7 @@ enum RoomStatus {
 }
 
 enum RoomType {
+  BOT
   PUBLIC
   PRIVATE
 }

backend/src/games/services/bot.ts

@@ -0,0 +1,71 @@
+import { Chess, Square } from "chess.js";
+import { Game, GameStatus } from "../../lib/types";
+import { logger } from "../../services/logger";
+import { StockfishEngine } from "./engine";
+import { GameService } from "./game";
+
+export const BOT_PLAYER_ID = "bot-player-001";
+export const BOT_NAME = "Computer";
+
+export class BotService {
+  private gameService: GameService;
+  private engine: StockfishEngine;
+
+  constructor(gameService: GameService) {
+    this.gameService = gameService;
+    this.engine = new StockfishEngine();
+    logger.info("BotService initialized with Stockfish engine.");
+  }
+
+  public async onGameUpdate(game: Game): Promise<void> {
+    if (game.status !== GameStatus.ACTIVE || !this.isBotTurn(game)) {
+      return;
+    }
+
+    const thinkingTime = this.getThinkingTime();
+    logger.info(`Bot is thinking for ~${thinkingTime}ms in game ${game.id}...`);
+
+    try {
+      await this.makeBotMove(game, thinkingTime);
+    } catch (error) {
+      logger.error(`Bot failed to make a move in game ${game.id}:`, error);
+    }
+  }
+
+  private isBotTurn(game: Game): boolean {
+    const botPlayer = game.players.find((p) => p.userId === BOT_PLAYER_ID);
+    if (!botPlayer) return false;
+
+    const chess = new Chess(game.fen);
+    return botPlayer.color.startsWith(chess.turn());
+  }
+
+  private async makeBotMove(game: Game, moveTime: number): Promise<void> {
+    const bestMoveUCI = await this.engine.findBestMove(game.fen, moveTime);
+
+    if (!bestMoveUCI || bestMoveUCI === "(none)") {
+      logger.warn(`Stockfish returned no move for game ${game.id}`);
+      return;
+    }
+
+    const from = bestMoveUCI.substring(0, 2) as Square;
+    const to = bestMoveUCI.substring(2, 4) as Square;
+    const promotion =
+      bestMoveUCI.length === 5 ? bestMoveUCI.substring(4) : undefined;
+
+    const move = { from, to, promotion };
+
+    logger.info(`Bot is making move ${bestMoveUCI} in game ${game.id}.`);
+
+    await this.gameService.makeMove(game.id, BOT_PLAYER_ID, move);
+  }
+
+  private getThinkingTime(): number {
+    return Math.floor(Math.random() * 2500) + 1500;
+  }
+
+  public shutdown(): void {
+    logger.info("Shutting down BotService and Stockfish engine.");
+    this.engine.quit();
+  }
+}

backend/src/games/services/engine.ts

@@ -0,0 +1,76 @@
+import { spawn, ChildProcessWithoutNullStreams } from "child_process";
+import { logger } from "../../services/logger";
+
+export class StockfishEngine {
+  private stockfish: ChildProcessWithoutNullStreams;
+  private isReady = false;
+  private listeners: ((message: string) => void)[] = [];
+
+  constructor() {
+    const stockfishPath = require.resolve(
+      "stockfish/src/stockfish-17.1-8e4d048.js"
+    );
+
+    this.stockfish = spawn("node", [stockfishPath]);
+
+    this.initializeListeners();
+  }
+
+  private initializeListeners(): void {
+    this.stockfish.stdout.on("data", (data: Buffer) => {
+      const messages = data.toString().split("\n").filter(Boolean);
+      for (const message of messages) {
+        const trimmedMessage = message.trim();
+        if (trimmedMessage.startsWith("uciok")) {
+          this.isReady = true;
+          logger.info("Stockfish engine is ready.");
+        }
+        this.listeners.forEach((listener) => listener(trimmedMessage));
+      }
+    });
+
+    this.stockfish.stderr.on("data", (data: Buffer) => {
+      logger.error(`Stockfish stderr: ${data.toString().trim()}`);
+    });
+
+    this.stockfish.on("close", (code) => {
+      if (code !== 0) {
+        logger.error(`Stockfish process exited with code ${code}`);
+      }
+    });
+
+    this.send("uci");
+  }
+
+  private send(command: string): void {
+    this.stockfish.stdin.write(`${command}\n`);
+  }
+
+  public findBestMove(fen: string, moveTime: number): Promise<string> {
+    return new Promise((resolve, reject) => {
+      if (!this.isReady) {
+        return setTimeout(() => {
+          this.findBestMove(fen, moveTime).then(resolve).catch(reject);
+        }, 500);
+      }
+
+      const onMessage = (message: string) => {
+        if (message.startsWith("bestmove")) {
+          const bestMove = message.split(" ")[1];
+          // Clean up this specific listener
+          this.listeners = this.listeners.filter((l) => l !== onMessage);
+          resolve(bestMove);
+        }
+      };
+
+      this.listeners.push(onMessage);
+
+      this.send(`position fen ${fen}`);
+      this.send(`go movetime ${moveTime}`);
+    });
+  }
+
+  public quit(): void {
+    this.send("quit");
+  }
+}

backend/src/games/services/game.ts

@@ -1,6 +1,4 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-
-// game file
 import { Chess, Square } from "chess.js";
 import { InputJsonValue } from "@prisma/client/runtime/library";
 
@@ -20,18 +18,25 @@ import { WebSocketService } from "../../services/websocket";
 import { redis } from "../../services/redis";
 import { UserStatus } from "@prisma/client";
 import { logger } from "../../services/logger";
+import { BOT_PLAYER_ID, BotService } from "./bot";
 
 export class GameService {
   private ws: WebSocketService;
+  private botService: BotService;
 
   private activeGames: Set<string> = new Set();
   private masterTimer: NodeJS.Timeout | null = null;
 
   constructor(ws: WebSocketService) {
     this.ws = ws;
+    this.botService = new BotService(this);
     this.startMasterTimer();
   }
 
+  public getBotService(): BotService {
+    return this.botService;
+  }
+
   private startMasterTimer(): void {
     if (this.masterTimer) return;
 
@@ -320,7 +325,9 @@ export class GameService {
     const player = game.players.find((p) => p.userId === playerId);
 
     if (!player || chess.turn() !== player.color[0]) {
-      throw new Error("Not your turn");
+      if (playerId !== BOT_PLAYER_ID) {
+        throw new Error("Not your turn");
+      }
     }
 
     const result = chess.move({
@@ -372,7 +379,7 @@ export class GameService {
     if (chess.isCheckmate()) {
       this.removeGameFromTimer(gameId);
       game.status = GameStatus.COMPLETED;
-      game.winnerId = player.userId;
+      game.winnerId = player?.userId;
     } else if (chess.isDraw()) {
       this.removeGameFromTimer(gameId);
       game.status = GameStatus.DRAW;
@@ -409,6 +416,8 @@ export class GameService {
     await redis.setJSON(`game:${gameId}`, game);
 
     this.ws.broadcastToGame(game);
+
+    await this.botService.onGameUpdate(game);
   }
 
   async getLegalMoves(