/** * 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, 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, 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, }); } } } // 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, }; }