bot freezing solved and difficulty levels reduced to the original three
This commit is contained in:
+123
-115
@@ -1,11 +1,12 @@
|
||||
/**
|
||||
* Advanced Chess AI Engine — deterministic minimax with alpha-beta pruning,
|
||||
* Chess AI Engine — deterministic negamax with alpha-beta pruning,
|
||||
* piece-square tables (PST), MVV-LVA move ordering, and quiescence search.
|
||||
* Differentiated depth and strategic profiles for Easy, Basic, and Hard.
|
||||
*/
|
||||
|
||||
import type { Rng } from "@3miz/game-server-sdk";
|
||||
import {
|
||||
isValidMove,
|
||||
isMoveLegalFor,
|
||||
isKingInCheck,
|
||||
isCheckmate,
|
||||
type State,
|
||||
@@ -104,8 +105,8 @@ function getPstScore(type: PieceType, color: "w" | "b", sq: number): number {
|
||||
}
|
||||
|
||||
/**
|
||||
* Static position evaluation from the perspective of white.
|
||||
* Returns a score in centipawns: positive favors White, negative favors Black.
|
||||
* Static position evaluation from White's perspective.
|
||||
* Positive favors White, negative favors Black.
|
||||
*/
|
||||
function evaluateStatic(s: State): number {
|
||||
let material = 0;
|
||||
@@ -115,17 +116,15 @@ function evaluateStatic(s: State): number {
|
||||
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;
|
||||
positional += getPstScore(p.type, p.color, sq);
|
||||
} else {
|
||||
material -= val;
|
||||
positional -= pst;
|
||||
positional -= getPstScore(p.type, p.color, sq);
|
||||
}
|
||||
}
|
||||
|
||||
// King check penalties / bonuses
|
||||
if (isKingInCheck(s, "w")) positional -= 40;
|
||||
if (isKingInCheck(s, "b")) positional += 40;
|
||||
|
||||
@@ -232,10 +231,10 @@ function unmakeMove(s: State, undo: UndoRecord) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate all legal moves for a given seat, ordered using MVV-LVA heuristics
|
||||
* Generate all legal moves for a given color, ordered using MVV-LVA heuristics.
|
||||
* Uses isMoveLegalFor so it is independent of whose turn it currently is in the root state.
|
||||
*/
|
||||
function generateOrderedMoves(s: State, seat: number): MoveCandidate[] {
|
||||
const color = s.players[seat].color;
|
||||
function generateOrderedMoves(s: State, color: "w" | "b", prioritizeCaptures = true): MoveCandidate[] {
|
||||
const moves: MoveCandidate[] = [];
|
||||
|
||||
for (let from = 0; from < 64; from++) {
|
||||
@@ -243,50 +242,52 @@ function generateOrderedMoves(s: State, seat: number): MoveCandidate[] {
|
||||
if (!p || p.color !== color) continue;
|
||||
|
||||
for (let to = 0; to < 64; to++) {
|
||||
if (isValidMove(s, from, to, seat)) {
|
||||
if (isMoveLegalFor(s, from, to, color)) {
|
||||
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;
|
||||
if (prioritizeCaptures) {
|
||||
// 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") {
|
||||
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;
|
||||
}
|
||||
|
||||
// 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;
|
||||
|
||||
const isPawnPromo = p.type === "p" && Math.floor(to / 8) === (color === "w" ? 7 : 0);
|
||||
moves.push({
|
||||
from,
|
||||
to,
|
||||
promotion: isPromo ? "q" : undefined,
|
||||
promotion: isPawnPromo ? "q" : undefined,
|
||||
score: moveScore,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Sort moves in descending order of predicted potential
|
||||
moves.sort((a, b) => b.score - a.score);
|
||||
if (prioritizeCaptures) {
|
||||
moves.sort((a, b) => b.score - a.score);
|
||||
}
|
||||
return moves;
|
||||
}
|
||||
|
||||
/**
|
||||
* Quiescence search to avoid horizon effect on loud capture positions
|
||||
* Quiescence search for loud capture sequences
|
||||
*/
|
||||
function quiescence(
|
||||
s: State,
|
||||
seat: number,
|
||||
alpha: number,
|
||||
beta: number,
|
||||
color: "w" | "b",
|
||||
@@ -297,12 +298,14 @@ function quiescence(
|
||||
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;
|
||||
const oppColor = color === "w" ? "b" : "w";
|
||||
const moves = generateOrderedMoves(s, color, true).filter(
|
||||
(m) => s.board[m.to] !== null || m.to === s.ep
|
||||
);
|
||||
|
||||
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);
|
||||
const score = -quiescence(s, -beta, -alpha, oppColor, depthLimit - 1);
|
||||
unmakeMove(s, undo);
|
||||
|
||||
if (score >= beta) return beta;
|
||||
@@ -312,66 +315,50 @@ function quiescence(
|
||||
}
|
||||
|
||||
/**
|
||||
* Minimax with Alpha-Beta Pruning
|
||||
* Negamax with Alpha-Beta Pruning
|
||||
*/
|
||||
function alphaBeta(
|
||||
function negamax(
|
||||
s: State,
|
||||
depth: number,
|
||||
alpha: number,
|
||||
beta: number,
|
||||
seat: number,
|
||||
botColor: "w" | "b",
|
||||
ply: number
|
||||
color: "w" | "b",
|
||||
ply: number,
|
||||
quiesceDepth: number
|
||||
): number {
|
||||
const currentColor = s.players[seat].color;
|
||||
const isBotTurn = currentColor === botColor;
|
||||
const oppColor = color === "w" ? "b" : "w";
|
||||
|
||||
if (isCheckmate(s, currentColor)) {
|
||||
// Checkmate penalty/reward scaled by ply to prefer faster mates
|
||||
return isBotTurn ? -100000 + ply : 100000 - ply;
|
||||
if (isCheckmate(s, color)) {
|
||||
// Current side to move is mated -> large penalty scaled by distance to root
|
||||
return -100000 + ply;
|
||||
}
|
||||
|
||||
if (depth <= 0) {
|
||||
return quiescence(s, seat, alpha, beta, currentColor, 2);
|
||||
if (quiesceDepth > 0) {
|
||||
return quiescence(s, alpha, beta, color, quiesceDepth);
|
||||
}
|
||||
return (color === "w" ? 1 : -1) * evaluateStatic(s);
|
||||
}
|
||||
|
||||
const moves = generateOrderedMoves(s, seat);
|
||||
const moves = generateOrderedMoves(s, color, true);
|
||||
if (moves.length === 0) {
|
||||
// Stalemate is a draw (0)
|
||||
return 0;
|
||||
}
|
||||
|
||||
const oppSeat = 1 - seat;
|
||||
for (const move of moves) {
|
||||
const undo = makeMove(s, move.from, move.to, move.promotion);
|
||||
const score = -negamax(s, depth - 1, -beta, -alpha, oppColor, ply + 1, quiesceDepth);
|
||||
unmakeMove(s, undo);
|
||||
|
||||
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;
|
||||
if (score >= beta) return beta;
|
||||
if (score > alpha) alpha = score;
|
||||
}
|
||||
return alpha;
|
||||
}
|
||||
|
||||
/**
|
||||
* Standard book openings for classic initial turns
|
||||
* Standard opening book moves
|
||||
*/
|
||||
const OPENING_BOOK_WHITE = [
|
||||
{ from: 12, to: 28 }, // e2 -> e4
|
||||
@@ -390,12 +377,12 @@ const OPENING_BOOK_BLACK: Record<string, { from: number; to: number }[]> = {
|
||||
// Against d2-d4:
|
||||
"27": [
|
||||
{ from: 51, to: 35 }, // d7 -> d5
|
||||
{ from: 62, to: 45 }, // g8 -> f6 (Indian Defense)
|
||||
{ from: 62, to: 45 }, // g8 -> f6 (Indian)
|
||||
],
|
||||
};
|
||||
|
||||
/**
|
||||
* Main bot entry point called by the game server
|
||||
* Main bot decision engine
|
||||
*/
|
||||
export function decideBot(
|
||||
s: State,
|
||||
@@ -406,8 +393,8 @@ export function decideBot(
|
||||
if (!player) return null;
|
||||
|
||||
const color = player.color;
|
||||
const level = player.level || "basic";
|
||||
const legalMoves = generateOrderedMoves(s, seat);
|
||||
const rawLevel = (player.level || "").toLowerCase().trim();
|
||||
const legalMoves = generateOrderedMoves(s, color, true);
|
||||
|
||||
if (legalMoves.length === 0) return null;
|
||||
if (legalMoves.length === 1) {
|
||||
@@ -418,52 +405,74 @@ export function decideBot(
|
||||
};
|
||||
}
|
||||
|
||||
// 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);
|
||||
// Difficulty profiles: easy (آسون), basic (معمولی), hard (سخت)
|
||||
let searchDepth = 2;
|
||||
let quiesceDepth = 1;
|
||||
let noiseRange = 0;
|
||||
let useOpeningBook = true;
|
||||
let blunderChancePercent = 0;
|
||||
|
||||
if (candidates) {
|
||||
const bookPick = candidates[rng.int(candidates.length)];
|
||||
if (isValidMove(s, bookPick.from, bookPick.to, seat)) {
|
||||
return { fromIdx: bookPick.from, toIdx: bookPick.to };
|
||||
if (rawLevel === "hard" || rawLevel === "expert" || rawLevel === "master") {
|
||||
// Hard (سخت): Depth 3 + 2 plies quiescence. Sharp, tactical, 0 blunders (~160ms).
|
||||
searchDepth = 3;
|
||||
quiesceDepth = 2;
|
||||
noiseRange = 0;
|
||||
useOpeningBook = true;
|
||||
blunderChancePercent = 0;
|
||||
} else if (rawLevel === "basic" || rawLevel === "normal") {
|
||||
// Basic / Normal (معمولی): Depth 2 + 1 ply quiescence. Solid play, small noise (~2ms).
|
||||
searchDepth = 2;
|
||||
quiesceDepth = 1;
|
||||
noiseRange = 10;
|
||||
useOpeningBook = true;
|
||||
blunderChancePercent = 5;
|
||||
} else {
|
||||
// Easy (آسون): Depth 1, no quiescence, higher noise & 25% casual blunders (~1ms).
|
||||
searchDepth = 1;
|
||||
quiesceDepth = 0;
|
||||
noiseRange = 50;
|
||||
useOpeningBook = false;
|
||||
blunderChancePercent = 25;
|
||||
}
|
||||
|
||||
// 1. Opening book selection on the first 2 moves of the game (if enabled)
|
||||
if (useOpeningBook) {
|
||||
if (s.moves_played === 0 && color === "w") {
|
||||
const pick = OPENING_BOOK_WHITE[rng.int(OPENING_BOOK_WHITE.length)];
|
||||
if (isMoveLegalFor(s, pick.from, pick.to, color)) {
|
||||
return { fromIdx: pick.from, toIdx: pick.to };
|
||||
}
|
||||
} else if (s.moves_played === 1 && color === "b") {
|
||||
const cand = s.board[28]?.type === "p" && s.board[28]?.color === "w"
|
||||
? OPENING_BOOK_BLACK["28"]
|
||||
: (s.board[27]?.type === "p" && s.board[27]?.color === "w" ? OPENING_BOOK_BLACK["27"] : null);
|
||||
|
||||
if (cand) {
|
||||
const pick = cand[rng.int(cand.length)];
|
||||
if (isMoveLegalFor(s, pick.from, pick.to, color)) {
|
||||
return { fromIdx: pick.from, toIdx: pick.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;
|
||||
// 2. Beginner blunder mechanism: integer-based check using rng.int(100) (never rng.float)
|
||||
if (blunderChancePercent > 0 && rng.int(100) < blunderChancePercent) {
|
||||
const nonCaptures = legalMoves.filter((m) => s.board[m.to] === null);
|
||||
if (nonCaptures.length > 0) {
|
||||
const pick = nonCaptures[rng.int(nonCaptures.length)];
|
||||
return { fromIdx: pick.from, toIdx: pick.to, promotion: pick.promotion };
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Minimax evaluation over all candidate root moves
|
||||
const oppSeat = 1 - seat;
|
||||
// 3. Negamax evaluation over all candidate root moves
|
||||
const oppColor = color === "w" ? "b" : "w";
|
||||
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);
|
||||
let evalScore = -negamax(s, searchDepth - 1, -Infinity, Infinity, oppColor, 1, quiesceDepth);
|
||||
unmakeMove(s, undo);
|
||||
|
||||
// Apply difficulty noise
|
||||
@@ -480,8 +489,7 @@ export function decideBot(
|
||||
}
|
||||
}
|
||||
|
||||
// Tie-breaker using deterministic rng
|
||||
const selected = bestMoves[rng.int(bestMoves.length)] || legalMoves[0];
|
||||
const selected = bestMoves.length > 0 ? bestMoves[rng.int(bestMoves.length)] : legalMoves[0];
|
||||
|
||||
return {
|
||||
fromIdx: selected.from,
|
||||
|
||||
Reference in New Issue
Block a user