bot freezing solved and difficulty levels reduced to the original three

This commit is contained in:
2026-10-15 14:08:13 +03:30
parent d8adef472e
commit 8ff113cfba
7 changed files with 148 additions and 126 deletions
+123 -115
View File
@@ -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,