diff --git a/server/bot.ts b/server/bot.ts index 5aa4075..0886910 100644 --- a/server/bot.ts +++ b/server/bot.ts @@ -1,24 +1,491 @@ /** - * Chess bot — basic random / tactical bot. + * Advanced Chess AI Engine — deterministic minimax with alpha-beta pruning, + * piece-square tables (PST), MVV-LVA move ordering, and quiescence search. */ -import type { Rng } from "@3miz/game-server-sdk"; -import { isValidMove, type State } from "./game.ts"; -export function decideBot(s: State, seat: number, rng: Rng): { fromIdx: number; toIdx: number } | null { - const player = s.players[seat]; - if (!player) return null; - const color = player.color; - const moves: { from: number; to: number }[] = []; - for (let i = 0; i < 64; i++) { - const piece = s.board[i]; - if (!piece || piece.color !== color) continue; +import type { Rng } from "@3miz/game-server-sdk"; +import { + isValidMove, + isKingInCheck, + isCheckmate, + type State, + type Piece, + type PieceType, +} from "./game.ts"; + +// Material values in centipawns +const PIECE_VALUES: Record = { + p: 100, + n: 320, + b: 330, + r: 500, + q: 900, + k: 20000, +}; + +// Piece-Square Tables (White perspective: rank 1 at index 0..7, rank 8 at index 56..63) +const PAWN_PST = [ + 0, 0, 0, 0, 0, 0, 0, 0, // rank 1 + 5, 10, 10, -20, -20, 10, 10, 5, // rank 2 + 5, -5, -10, 0, 0, -10, -5, 5, // rank 3 + 0, 0, 0, 25, 25, 0, 0, 0, // rank 4 + 5, 5, 10, 25, 25, 10, 5, 5, // rank 5 + 10, 10, 20, 30, 30, 20, 10, 10, // rank 6 + 50, 50, 50, 50, 50, 50, 50, 50, // rank 7 + 0, 0, 0, 0, 0, 0, 0, 0, // rank 8 +]; + +const KNIGHT_PST = [ + -50, -40, -30, -30, -30, -30, -40, -50, + -40, -20, 0, 5, 5, 0, -20, -40, + -30, 5, 15, 20, 20, 15, 5, -30, + -30, 5, 20, 30, 30, 20, 5, -30, + -30, 5, 20, 30, 30, 20, 5, -30, + -30, 5, 15, 20, 20, 15, 5, -30, + -40, -20, 0, 5, 5, 0, -20, -40, + -50, -40, -30, -30, -30, -30, -40, -50, +]; + +const BISHOP_PST = [ + -20, -10, -10, -10, -10, -10, -10, -20, + -10, 5, 0, 0, 0, 0, 5, -10, + -10, 10, 10, 10, 10, 10, 10, -10, + -10, 0, 10, 15, 15, 10, 0, -10, + -10, 5, 5, 15, 15, 5, 5, -10, + -10, 0, 5, 10, 10, 5, 0, -10, + -10, 0, 0, 0, 0, 0, 0, -10, + -20, -10, -10, -10, -10, -10, -10, -20, +]; + +const ROOK_PST = [ + 0, 0, 0, 5, 5, 0, 0, 0, + -5, 0, 0, 0, 0, 0, 0, -5, + -5, 0, 0, 0, 0, 0, 0, -5, + -5, 0, 0, 0, 0, 0, 0, -5, + -5, 0, 0, 0, 0, 0, 0, -5, + -5, 0, 0, 0, 0, 0, 0, -5, + 5, 10, 10, 10, 10, 10, 10, 5, + 0, 0, 0, 0, 0, 0, 0, 0, +]; + +const QUEEN_PST = [ + -20, -10, -10, -5, -5, -10, -10, -20, + -10, 0, 5, 0, 0, 0, 0, -10, + -10, 5, 5, 5, 5, 5, 0, -10, + 0, 0, 5, 5, 5, 5, 0, -5, + -5, 0, 5, 5, 5, 5, 0, -5, + -10, 0, 5, 5, 5, 5, 0, -10, + -10, 0, 0, 0, 0, 0, 0, -10, + -20, -10, -10, -5, -5, -10, -10, -20, +]; + +const KING_PST = [ + 20, 30, 10, 0, 0, 10, 30, 20, + 20, 20, 0, 0, 0, 0, 20, 20, + -10, -20, -20, -20, -20, -20, -20, -10, + -20, -30, -30, -40, -40, -30, -30, -20, + -30, -40, -40, -50, -50, -40, -40, -30, + -30, -40, -40, -50, -50, -40, -40, -30, + -30, -40, -40, -50, -50, -40, -40, -30, + -30, -40, -40, -50, -50, -40, -40, -30, +]; + +function getPstScore(type: PieceType, color: "w" | "b", sq: number): number { + const pstSq = color === "w" ? sq : (7 - Math.floor(sq / 8)) * 8 + (sq % 8); + switch (type) { + case "p": return PAWN_PST[pstSq] ?? 0; + case "n": return KNIGHT_PST[pstSq] ?? 0; + case "b": return BISHOP_PST[pstSq] ?? 0; + case "r": return ROOK_PST[pstSq] ?? 0; + case "q": return QUEEN_PST[pstSq] ?? 0; + case "k": return KING_PST[pstSq] ?? 0; + default: return 0; + } +} + +/** + * Static position evaluation from the perspective of white. + * Returns a score in centipawns: positive favors White, negative favors Black. + */ +function evaluateStatic(s: State): number { + let material = 0; + let positional = 0; + + for (let sq = 0; sq < 64; sq++) { + const p = s.board[sq]; + if (!p) continue; + const val = PIECE_VALUES[p.type] ?? 0; + const pst = getPstScore(p.type, p.color, sq); + if (p.color === "w") { + material += val; + positional += pst; + } else { + material -= val; + positional -= pst; + } + } + + // King check penalties / bonuses + if (isKingInCheck(s, "w")) positional -= 40; + if (isKingInCheck(s, "b")) positional += 40; + + return material + positional; +} + +interface MoveCandidate { + from: number; + to: number; + promotion?: PieceType; + score: number; +} + +interface UndoRecord { + from: number; + to: number; + moving: Piece; + captured: Piece | null; + prevEp: number | null; + prevRights: { wk: boolean; wq: boolean; bk: boolean; bq: boolean }; + isCastling: boolean; + rookFrom?: number; + rookTo?: number; + isEp: boolean; + epVictimSq?: number; + epVictimPiece?: Piece | null; +} + +function makeMove(s: State, from: number, to: number, promotion?: PieceType): UndoRecord { + const moving = s.board[from]!; + const captured = s.board[to]; + + const undo: UndoRecord = { + from, + to, + moving, + captured, + prevEp: s.ep, + prevRights: { ...s.rights }, + isCastling: false, + isEp: false, + }; + + // En passant + if (moving.type === "p" && to === s.ep && !captured) { + undo.isEp = true; + undo.epVictimSq = to + (moving.color === "w" ? -8 : 8); + undo.epVictimPiece = s.board[undo.epVictimSq]; + s.board[undo.epVictimSq] = null; + } + + // Castling + if (moving.type === "k" && Math.abs((to % 8) - (from % 8)) === 2) { + undo.isCastling = true; + undo.rookFrom = to > from ? to + 1 : to - 2; + undo.rookTo = to > from ? to - 1 : to + 1; + s.board[undo.rookTo] = s.board[undo.rookFrom]; + s.board[undo.rookFrom] = null; + } + + // Double step opening en passant + s.ep = null; + if (moving.type === "p" && Math.abs(to - from) === 16) { + s.ep = from + (moving.color === "w" ? 8 : -8); + } + + // Promotion + const lastRank = moving.color === "w" ? 7 : 0; + if (moving.type === "p" && Math.floor(to / 8) === lastRank) { + s.board[to] = { type: promotion ?? "q", color: moving.color }; + } else { + s.board[to] = moving; + } + s.board[from] = null; + + // Rights decay + if (moving.type === "k") { + if (moving.color === "w") { s.rights.wk = false; s.rights.wq = false; } + else { s.rights.bk = false; s.rights.bq = false; } + } else if (moving.type === "r") { + if (from === 0) s.rights.wq = false; + else if (from === 7) s.rights.wk = false; + else if (from === 56) s.rights.bq = false; + else if (from === 63) s.rights.bk = false; + } + + return undo; +} + +function unmakeMove(s: State, undo: UndoRecord) { + s.board[undo.from] = undo.moving; + s.board[undo.to] = undo.captured; + s.ep = undo.prevEp; + s.rights = undo.prevRights; + + if (undo.isCastling && undo.rookFrom !== undefined && undo.rookTo !== undefined) { + s.board[undo.rookFrom] = s.board[undo.rookTo]; + s.board[undo.rookTo] = null; + } + + if (undo.isEp && undo.epVictimSq !== undefined) { + s.board[undo.epVictimSq] = undo.epVictimPiece ?? null; + } +} + +/** + * Generate all legal moves for a given seat, ordered using MVV-LVA heuristics + */ +function generateOrderedMoves(s: State, seat: number): MoveCandidate[] { + const color = s.players[seat].color; + const moves: MoveCandidate[] = []; + + for (let from = 0; from < 64; from++) { + const p = s.board[from]; + if (!p || p.color !== color) continue; + for (let to = 0; to < 64; to++) { - if (isValidMove(s, i, to, seat)) { - moves.push({ from: i, to }); + if (isValidMove(s, from, to, seat)) { + const target = s.board[to]; + let moveScore = 0; + + // MVV-LVA: Most Valuable Victim - Least Valuable Attacker + if (target) { + moveScore = 1000 + (PIECE_VALUES[target.type] ?? 0) * 10 - (PIECE_VALUES[p.type] ?? 0); + } else if (to === s.ep && p.type === "p") { + // En passant capture + moveScore = 1000 + 100 * 10 - 100; + } + + // Promotion bonus + const lastRank = color === "w" ? 7 : 0; + const isPromo = p.type === "p" && Math.floor(to / 8) === lastRank; + if (isPromo) { + moveScore += 900; + } + + // Positional gain + const pstGain = getPstScore(p.type, color, to) - getPstScore(p.type, color, from); + moveScore += pstGain; + + moves.push({ + from, + to, + promotion: isPromo ? "q" : undefined, + score: moveScore, + }); } } } - if (moves.length === 0) return null; - const pick = moves[rng.int(moves.length)]; - return { fromIdx: pick.from, toIdx: pick.to }; + + // Sort moves in descending order of predicted potential + moves.sort((a, b) => b.score - a.score); + return moves; +} + +/** + * Quiescence search to avoid horizon effect on loud capture positions + */ +function quiescence( + s: State, + seat: number, + alpha: number, + beta: number, + color: "w" | "b", + depthLimit: number +): number { + const standPat = (color === "w" ? 1 : -1) * evaluateStatic(s); + if (standPat >= beta) return beta; + if (standPat > alpha) alpha = standPat; + if (depthLimit <= 0) return alpha; + + const moves = generateOrderedMoves(s, seat).filter((m) => s.board[m.to] !== null || m.to === s.ep); + const oppSeat = 1 - seat; + + for (const move of moves) { + const undo = makeMove(s, move.from, move.to, move.promotion); + const score = -quiescence(s, oppSeat, -beta, -alpha, color === "w" ? "b" : "w", depthLimit - 1); + unmakeMove(s, undo); + + if (score >= beta) return beta; + if (score > alpha) alpha = score; + } + return alpha; +} + +/** + * Minimax with Alpha-Beta Pruning + */ +function alphaBeta( + s: State, + depth: number, + alpha: number, + beta: number, + seat: number, + botColor: "w" | "b", + ply: number +): number { + const currentColor = s.players[seat].color; + const isBotTurn = currentColor === botColor; + + if (isCheckmate(s, currentColor)) { + // Checkmate penalty/reward scaled by ply to prefer faster mates + return isBotTurn ? -100000 + ply : 100000 - ply; + } + + if (depth <= 0) { + return quiescence(s, seat, alpha, beta, currentColor, 2); + } + + const moves = generateOrderedMoves(s, seat); + if (moves.length === 0) { + // Stalemate is a draw (0) + return 0; + } + + const oppSeat = 1 - seat; + + if (isBotTurn) { + let maxEval = -Infinity; + for (const move of moves) { + const undo = makeMove(s, move.from, move.to, move.promotion); + const evalScore = alphaBeta(s, depth - 1, alpha, beta, oppSeat, botColor, ply + 1); + unmakeMove(s, undo); + + maxEval = Math.max(maxEval, evalScore); + alpha = Math.max(alpha, evalScore); + if (beta <= alpha) break; // Beta cutoff + } + return maxEval; + } else { + let minEval = Infinity; + for (const move of moves) { + const undo = makeMove(s, move.from, move.to, move.promotion); + const evalScore = alphaBeta(s, depth - 1, alpha, beta, oppSeat, botColor, ply + 1); + unmakeMove(s, undo); + + minEval = Math.min(minEval, evalScore); + beta = Math.min(beta, evalScore); + if (beta <= alpha) break; // Alpha cutoff + } + return minEval; + } +} + +/** + * Standard book openings for classic initial turns + */ +const OPENING_BOOK_WHITE = [ + { from: 12, to: 28 }, // e2 -> e4 + { from: 11, to: 27 }, // d2 -> d4 + { from: 6, to: 21 }, // g1 -> f3 + { from: 10, to: 26 }, // c2 -> c4 +]; + +const OPENING_BOOK_BLACK: Record = { + // Against e2-e4: + "28": [ + { from: 52, to: 36 }, // e7 -> e5 + { from: 50, to: 34 }, // c7 -> c5 (Sicilian) + { from: 52, to: 44 }, // e7 -> e6 (French) + ], + // Against d2-d4: + "27": [ + { from: 51, to: 35 }, // d7 -> d5 + { from: 62, to: 45 }, // g8 -> f6 (Indian Defense) + ], +}; + +/** + * Main bot entry point called by the game server + */ +export function decideBot( + s: State, + seat: number, + rng: Rng +): { fromIdx: number; toIdx: number; promotion?: PieceType } | null { + const player = s.players[seat]; + if (!player) return null; + + const color = player.color; + const level = player.level || "basic"; + const legalMoves = generateOrderedMoves(s, seat); + + if (legalMoves.length === 0) return null; + if (legalMoves.length === 1) { + return { + fromIdx: legalMoves[0].from, + toIdx: legalMoves[0].to, + promotion: legalMoves[0].promotion, + }; + } + + // 1. Opening book selection on the first 2 moves of the game + if (s.moves_played === 0 && color === "w") { + const bookPick = OPENING_BOOK_WHITE[rng.int(OPENING_BOOK_WHITE.length)]; + if (isValidMove(s, bookPick.from, bookPick.to, seat)) { + return { fromIdx: bookPick.from, toIdx: bookPick.to }; + } + } else if (s.moves_played === 1 && color === "b") { + // Find what white played + const whitePawnOnE4 = s.board[28]?.type === "p" && s.board[28]?.color === "w"; + const whitePawnOnD4 = s.board[27]?.type === "p" && s.board[27]?.color === "w"; + const candidates = whitePawnOnE4 + ? OPENING_BOOK_BLACK["28"] + : (whitePawnOnD4 ? OPENING_BOOK_BLACK["27"] : null); + + if (candidates) { + const bookPick = candidates[rng.int(candidates.length)]; + if (isValidMove(s, bookPick.from, bookPick.to, seat)) { + return { fromIdx: bookPick.from, toIdx: bookPick.to }; + } + } + } + + // 2. Search depth based on configured difficulty level + let searchDepth = 2; + let noiseRange = 0; + + if (level === "hard") { + searchDepth = 3; + noiseRange = 0; + } else if (level === "easy") { + searchDepth = 1; + noiseRange = 35; // Casual noise to allow human-like minor inaccuracies + } else { + // "basic" + searchDepth = 2; + noiseRange = 8; + } + + // 3. Minimax evaluation over all candidate root moves + const oppSeat = 1 - seat; + let bestScore = -Infinity; + let bestMoves: MoveCandidate[] = []; + + for (const move of legalMoves) { + const undo = makeMove(s, move.from, move.to, move.promotion); + let evalScore = alphaBeta(s, searchDepth - 1, -Infinity, Infinity, oppSeat, color, 1); + unmakeMove(s, undo); + + // Apply difficulty noise + if (noiseRange > 0) { + const jitter = rng.int(noiseRange * 2 + 1) - noiseRange; + evalScore += jitter; + } + + if (evalScore > bestScore) { + bestScore = evalScore; + bestMoves = [move]; + } else if (Math.abs(evalScore - bestScore) <= 2) { + bestMoves.push(move); + } + } + + // Tie-breaker using deterministic rng + const selected = bestMoves[rng.int(bestMoves.length)] || legalMoves[0]; + + return { + fromIdx: selected.from, + toIdx: selected.to, + promotion: selected.promotion, + }; } diff --git a/server/game.ts b/server/game.ts index 4ffd6ff..dc3b88d 100644 --- a/server/game.ts +++ b/server/game.ts @@ -510,7 +510,7 @@ function handleBotMove(s: State, ctx: Ctx) { const seatBefore = s.turn; const botMove = decideBot(s, s.turn, ctx.rng); if (botMove !== null && typeof botMove.fromIdx === "number" && typeof botMove.toIdx === "number") { - applyMove(s, botMove.fromIdx, botMove.toIdx, seatBefore); + applyMove(s, botMove.fromIdx, botMove.toIdx, seatBefore, botMove.promotion); return postMove(s, ctx, seatBefore); } // Bot has no legal move: mated if in check, otherwise stalemate draw.