♞ Advanced Chess AI with Minimax

Project Overview — What Makes This "Advanced"

This version upgrades the basic random-move AI into a position-aware minimax engine with alpha-beta pruning. It evaluates not just material, but where each piece stands on the board, using classic piece-square tables. The search depth is configurable (default: 3 plies) and uses ES2024 features like Object.groupBy and the ||= logical assignment operator.

// Architecture overview:
        class ModernChess {
            #aiSearchDepth = 3;  // plies to search
            // ... piece-square tables (PAWN_TABLE, KNIGHT_TABLE, etc.)
            // ... minimax() with alpha-beta pruning
            // ... evaluateBoard() using positional tables
        }

Piece-Square Positional Tables

Each piece type has an 8×8 centipawn table that encodes strategic knowledge: knights belong near the centre, rooks on open files, kings sheltered behind pawns in the opening. These values are added to the base material value of each piece during evaluation.

const KNIGHT_TABLE = [
            [-50,-40,-30,-30,-30,-30,-40,-50],
            [-40,-20,  0,  0,  0,  0,-20,-40],
            [-30,  0, 10, 15, 15, 10,  0,-30],
            [-30,  5, 15, 20, 20, 15,  5,-30],
            [-30,  0, 15, 20, 20, 15,  0,-30],
            [-30,  5, 10, 15, 15, 10,  5,-30],
            [-40,-20,  0,  5,  5,  0,-20,-40],
            [-50,-40,-30,-30,-30,-30,-40,-50]
        ];
        // Centre squares (d4,e4,d5,e5) give +20 bonus for knights
    // Corners are heavily penalised (-50) — knights on the rim are grim!

Board Evaluation — Combining Material & Position

The #evaluateBoard() method scans all 64 squares. For each occupied square, it calls #getPieceValue() which sums the base material value (pawn=100, knight=320, bishop=330, rook=500, queen=900, king=20000) with the positional bonus from the corresponding piece-square table. Black pieces add positive values; white pieces subtract (from the AI's perspective as Black).

#getPieceValue(piece, x, y) {
            const baseValues = { p: 100, n: 320, b: 330, r: 500, q: 900, k: 20000 };
            let value = baseValues[piece.type] ?? 0;

            let positionalBonus = 0;
            if (piece.type === 'p') positionalBonus = PAWN_TABLE[x][y];
            else if (piece.type === 'n') positionalBonus = KNIGHT_TABLE[x][y];
            // ... same for b, r, q, k

            // AI is Black: black pieces ADD, white pieces SUBTRACT
            return piece.color === 'b' ? (value + positionalBonus) : -(value + positionalBonus);
        }

ES2024: Object.groupBy for Piece Classification

The code uses Object.groupBy (a brand-new ES2024 static method) to split all pieces on the board into white and black groups in a single call. This replaces manual loops and makes the structural analysis of the position cleaner and more readable.

const flatBoard = this.#game.board().flat().filter(Boolean);

        // ES2024: group all pieces by their color in one call
        const piecesGrouped = Object.groupBy(flatBoard, piece => piece.color);
        // Result: { w: [...all white pieces], b: [...all black pieces] }

        // Useful for: counting material, checking piece counts, structural analysis
    const whitePieceCount = piecesGrouped.w?.length ?? 0;

The Minimax Algorithm — Core Concept

Minimax is the foundational algorithm for two-player zero-sum games. The AI assumes both players play optimally: maximising player (Black/AI) tries to maximise the evaluation score, while the minimising player (White/human) tries to minimise it. The algorithm recursively explores future positions up to a fixed depth and backs up the best value.

#minimax(depth, alpha, beta, isMaximizing) {
            if (depth === 0 || this.#game.game_over()) {
            return this.#evaluateBoard();  // leaf node → static evaluation
            }

            const moves = this.#game.moves({ verbose: true });

            if (isMaximizing) {
            let maxEval = -Infinity;
            for (const move of moves) {
            this.#game.move(move);
            let evaluation = this.#minimax(depth - 1, alpha, beta, false);
            this.#game.undo();
            maxEval = Math.max(maxEval, evaluation);
            }
            return maxEval;
            } else {
            // minimising player — same structure, uses Math.min
            }
        }

Alpha-Beta Pruning — Cutting the Search Tree

Alpha-beta pruning dramatically reduces the number of nodes evaluated by the minimax algorithm. It tracks two bounds: alpha (best already found for the maximiser) and beta (best already found for the minimiser). When a branch can't possibly influence the final decision, it's pruned — skipped entirely. This cuts the effective branching factor from ~35 to roughly √35 ≈ 6, making depth-3 searches blazing fast.

// Inside the maximising loop:
        alpha = Math.max(alpha, evaluation);
        if (beta <= alpha) break;  // Beta cutoff — prune this branch!

        // Inside the minimising loop:
        beta = Math.min(beta, evaluation);
    if (beta <= alpha) break;  // Alpha cutoff — prune this branch!

Move Ordering — Making Pruning More Effective

Alpha-beta pruning works best when strong moves are examined first. The code implements a simple but effective heuristic: captures are sorted before quiet moves. This increases the chance of early cutoffs, further reducing the search space. Advanced engines add killer moves and history heuristics, but capture-first ordering already provides a significant speedup.

// Before the minimax loop, sort moves to maximise pruning:
        const moves = this.#game.moves({ verbose: true });
        moves.sort((a, b) => {
            // Captures first (b.captured is truthy if the move captures a piece)
            return (b.captured ? 1 : 0) - (a.captured ? 1 : 0);
        });

ES2024: Logical Assignment (||=)

The #showMessage method uses the logical OR assignment operator (||=), another ES2024 feature. It assigns a value only if the left-hand side is falsy (null, undefined, false, 0, or empty string). This provides a clean, one-line default parameter pattern without cluttering the method signature.

#showMessage(msg, bgColor) {
            // ES2024: assign default only if bgColor is falsy
            bgColor ||= "#ff4757dd";

            // Equivalent to: if (!bgColor) bgColor = "#ff4757dd";
            // But shorter, more idiomatic, and part of the spec

            const errDiv = document.getElementById('errorMsg');
            errDiv.textContent = msg;
            errDiv.style.background = bgColor;
            // ... auto-dismiss timeout
        }

AI Entry Point — Root Search

The #executeEngineAI() method is the entry point for the AI's turn. It iterates over all legal moves, calls #minimax on each, and selects the move with the highest evaluation. The #aiSearchDepth private field (default: 3) controls how many plies deep the search goes. After the best move is found, it's executed on the real board.

#executeEngineAI() {
            let bestMove = null;
            let bestValue = -Infinity;
            let alpha = -Infinity, beta = Infinity;
            const moves = this.#game.moves({ verbose: true });
            moves.sort((a, b) => (b.captured ? 1 : 0) - (a.captured ? 1 : 0));

            for (const move of moves) {
            this.#game.move(move);
            let boardValue = this.#minimax(this.#aiSearchDepth - 1, alpha, beta, false);
            this.#game.undo();
            if (boardValue > bestValue) { bestValue = boardValue; bestMove = move; }
            alpha = Math.max(alpha, bestValue);
            }
            if (bestMove) this.#game.move(bestMove);
        }

All Piece-Square Tables at a Glance

Here are the actual centipawn values used by the engine. Positive values mean the square is favourable for that piece; negative values mean it's a bad square. The AI naturally gravitates toward high-value squares.