Chess Validation

view live code

White to move

20 available moves

Highlights - Click to enable:

none

last move

attacks

checks

Live Page code

The code behind this demo, read alongside the associating blog post.

The code is not entirely ordered in the same way as the blog post, so I recommend you finish reading it first.

Chess logic

Piece movement

// Scroll + 🖱️ to pan sideways →

// Movement for the Knight
export function knightMoves(knight: Piece) {
    const knightOffsets = [
        [2, 1], [2, -1], [-2, 1], [-2, -1], [1, 2], [1, -2], [-1, 2], [-1, -2]
    ];

    for (let offset of knightOffsets) {
        let move = knight.offset( offset[0], offset[1] );
        if (!move.onBoard()) continue;

        // During ATTACK, still mark squares defended by our own pieces - otherwise a king
        // could illegally capture a piece the knight is protecting
        if (hasFriendlyPiece(move) && gameBoard.phase !== Phase.ATTACK) continue;

        validateSpot(move);
    }
}


// Movement for the Pawns, including En Passant and Pseudo-pin logic
export function pawnMoves(pawn: Piece) {
    if (gameBoard.phase === Phase.ATTACK) {
        // Pawns are the only moves that attack different compared to how they move,
        // thus the distinction here. It always defends these two spots
        validateSpot(pawn.inFront().left());
        validateSpot(pawn.inFront().right());

    } else {
        // Simple moves
        if (!hasPiece(pawn.inFront())) validateSpot(pawn.inFront()); // Single move
        if (!hasPiece(pawn.inFront()) && !hasPiece(pawn.inFront().inFront()) && !pawn.hasMoved )
            validateSpot(pawn.inFront().inFront()); // Double move

        if (hasEnemyPiece(pawn.inFront().left())) validateSpot(pawn.inFront().left());
        if (hasEnemyPiece(pawn.inFront().right())) validateSpot(pawn.inFront().right());

        // Edge Case Nr.2: 'En Passant Pseudo-pin'
        // This is marked, simply, in markPinIfFound(), under 'Pinned Pieces'
        const pseudoPinned = gameBoard.markings.get(pawn.row, pawn.column).has(Marking.PSEUDO_PINNED);

        // The isEnPassantable flag is set in movePiece(), under 'Game Flow',
        // right after a pawn has moved two squares
        if (!pseudoPinned && isEnPassantable(pawn.inFront().left())) validateSpot(pawn.inFront().left());
        if (!pseudoPinned && isEnPassantable(pawn.inFront().right())) validateSpot(pawn.inFront().right());
    }
}

// Movement for the King, including avoiding defended squares
export function kingMoves(king: Piece) {
    const kingAdjacentSquares = [
        [1, 1], [-1, 1], [1, -1], [-1, -1], [1, 0], [-1, 0], [0, 1], [0, -1]
    ];

    for (let square of kingAdjacentSquares) {
        let move = king.offset(square[0], square[1]);

        if (!move.onBoard() || hasFriendlyPiece(move)
                || gameBoard.markings.get(move.row, move.column).has(Marking.ATTACKED)) continue;

        validateSpot(move);
    }

    attemptCastle(king, 1);
    attemptCastle(king, -1);
}

// The movement code for long-range pieces is in the section below this one,
// as their combined movement logic is substantially more complex

↳ Long-range movement

// Scroll + 🖱️ to pan sideways →

// Movement for the Rook
export function rookMoves(rook: Piece) {
    const rookDirections = [
        [1, 0], [-1, 0], [0, 1], [0, -1]
    ];

    for (let direction of rookDirections) {
        resetTraceState();
        traceSpots(rook.offset(direction[0], direction[1]), direction);
        markPinIfFound();
    }
}

// Movement for the Bishop
export function bishopMoves(bishop: Piece) {
    const bishopDirections = [
        [1, 1], [-1, 1], [1, -1], [-1, -1]
    ];

    for (let direction of bishopDirections) {
        resetTraceState();
        traceSpots(bishop.offset(direction[0], direction[1]), direction);
        markPinIfFound();
    }
}

// Movement for the Queen
export function queenMoves(queen: Piece) {
    const queenDirections = [
        [1, 1], [-1, 1], [1, -1], [-1, -1], [1, 0], [-1, 0], [0, 1], [0, -1]
    ];

    for (let direction of queenDirections) {
        resetTraceState();
        traceSpots(queen.offset(direction[0], direction[1]), direction);
        markPinIfFound();
    }
}

// A recursive function used by all long-range pieces to validate a line of squares in sequence.
// It also partly handles marking pieces as pinned
function traceSpots(move: Piece, direction: number[]) {
    if (!move.onBoard()) return;

    // Remember whether we passed through an En Passantable piece for Pseudo-pin detection
    const enPassantable = gameBoard.phase === Phase.ATTACK && traceState.firstHit == null
            && gameBoard.markings.get(move.row, move.column).has(Marking.EN_PASSANTABLE);
    if (enPassantable) traceState.passedEnPassantable = true;

    // Can't do anything other than defend you
    if (hasFriendlyPiece(move) && gameBoard.phase !== Phase.ATTACK) return;

    let piece = gameBoard.getPiece(move);
    if (piece != null && piece.isOpponentKing(move)) traceState.foundKing = true;

    // If this is the second piece we hit, stop, unless it's En Passantable
    const enemy = !enPassantable && hasEnemyPiece(move);
    if (enemy && traceState.firstHit != null) return;

    const alreadyHadHit = traceState.firstHit != null;

    // If we hadn't hit anything before, we hit the current move now
    if (enemy) traceState.firstHit = move;

    // Validate up through the first hit as normal, but during Phase.ATTACK keep going past it if
    // that hit was the opponent king, so squares directly behind the king still get marked ATTACKED
    if (!alreadyHadHit || (traceState.foundKing && gameBoard.phase === Phase.ATTACK)) validateSpot(move);

    if (piece != null && !enemy && !enPassantable) return;

    // Recursive call, continue going in the same direction
    traceSpots(move.offset(direction[0], direction[1]), direction);

    // Only mark squares between this piece and the king, not behind it
    const king = getKing(otherColor(move.color));
    if (king.manhattanDist(move.pieceRow, move.pieceColumn) < move.manhattanDist(move.pieceRow, move.pieceColumn)) return;


    // This will always run after the recursion has ended, at all positions of the ray,
    // mark as line of check if we have been confirmed to be the origin of a check
    if (traceState.checkOrigin) gameBoard.markings.get(move.row, move.column).add(Marking.CHECK_LINE);
}

Special Moves

// Scroll + 🖱️ to pan sideways →

// Utility function for finding a rook in a certain direction for castling. Checks it has not moved,
// and there are no pieces in the way. Returns null otherwise
export function findRookForCastle(king: Piece, direction: number): Piece | null {
    let scan = king.offset(0, direction);
    while (scan.onBoard()) {
        const found = gameBoard.getPiece(scan);
        if (found != null) return found.type === Type.ROOK && found.color === king.color && !found.hasMoved ? found : null;
        scan = scan.offset(0, direction);
    }
    return null;
}

// Check castling opportunities on both sides. Called directly from the King's movement function
export function attemptCastle(king: Piece, direction: number) {
    if (gameBoard.phase === Phase.ATTACK || king.hasMoved) return;
    if (gameBoard.checkCount > 0) return; // In check

    const rook = findRookForCastle(king, direction);
    if (rook == null) return;

    const first = king.offset(0, direction);
    const second = king.offset(0, direction * 2);

    if (gameBoard.markings.get(first.row, first.column).has(Marking.ATTACKED)) return;
    if (gameBoard.markings.get(second.row, second.column).has(Marking.ATTACKED)) return;

    validateSpot(second);
}

// Runs when the player has selected a promotion for their piece. Swaps it out on the board,
// and then resumes the post-move code that was paused in movePiece() under 'Game Flow'
export function promotePiece(type: Type) {
    const pawn = gameBoard.promotingPiece;
    if (pawn == null) return;

    const promoted = new Piece(type, pawn.color, pawn.row, pawn.column, pawn.row, pawn.column, true);
    gameBoard.pieces.set(promoted.row, promoted.column, promoted);
    gameBoard.promotingPiece = null;

    postMove();
}

Pinned Pieces

// Scroll + 🖱️ to pan sideways →

// Part of the long-range tracing logic. We check if the first piece we hit is actually pinned on a king
export function markPinIfFound() {
    const hit: Position | null = traceState.firstHit;

    // If we're not looking for pins right now, never found a King or never hit any piece at all, do nothing
    if (gameBoard.phase !== Phase.ATTACK || !traceState.foundKing || hit == null) return;

    const hitPiece = gameBoard.getPiece(hit);
    if (hitPiece == null || hitPiece.type === Type.KING) return; // Make sure a King can't be pinned on itself

    gameBoard.markings.get(hit.row, hit.column).add(traceState.passedEnPassantable ? Marking.PSEUDO_PINNED : Marking.PINNED);
}

// Checks whether the piece position, move and king positions line up. If not, the pinned
// piece will not be allowed to move to this square.
export function moveLinesUpWithKing(move: Piece) {
    const king = getKing(move.color);

    const toKingRow = king.row - move.pieceRow;
    const toKingColumn = king.column - move.pieceColumn;
    const toMoveRow = move.row - move.pieceRow;
    const toMoveColumn = move.column - move.pieceColumn;

    return toKingRow * toMoveColumn === toKingColumn * toMoveRow;
}

Mate & Stalemate detection

// Scroll + 🖱️ to pan sideways →

export let endMessage: string | null = null;

// Reset the message that appears after a game ended
export function resetGameOver() {
    endMessage = null;
}

// Mate/stalemate detection: postMove above already computes availableMoves for the side about to
// move, so this just has to interpret that count against whether they're in check
export function checkGameOver(): boolean {
    if (gameBoard.availableMoves > 0) return false;

    gameBoard.phase = Phase.OVER;

    if (gameBoard.checkCount == 0) {
        endMessage = "Stalemate.";
    } else {
        endMessage = `${otherColor(gameBoard.currentTurn)} got Checkmated!`;
    }
    return true;
}

Move Validation

// Scroll + 🖱️ to pan sideways →

// The final validation filter function that does two things:
// - Filter away pseudo-valid moves that are blocked by niche rules
// - Decide how the move should be validated, depending on the current game Phase
export function validateSpot(move: Piece) {
    if (!move.onBoard()) return;

    switch (gameBoard.phase) {
        // Normal behavior, seeing what moves are valid and counting
        // how many valid moves one of the players still has
        case Phase.VALIDATE_MOVES:
        case Phase.COUNT_MOVES: {
            // Marking pieces as pinned is done by the logic under 'Long-ranged movement' and 'Pinned Pieces'
            const pinned = gameBoard.markings.get(move.pieceRow, move.pieceColumn).has(Marking.PINNED);

            // If this piece is pinned, it can only be moved in line with the King, as not to break the pin
            if (pinned && !moveLinesUpWithKing(move)) return;

            // If there are 2 or more checks, this piece can't get the king out of check and thus can't move
            if (gameBoard.checkCount >= 2 && move.type !== Type.KING) return;

            // If there's exactly 1 check (and we're not the King), we may be able to stop it by capturing or
            // blocking. This block rules out the possibility of both before we mark this move as valid
            if (gameBoard.checkCount === 1 && move.type !== Type.KING
                && !gameBoard.markings.get(move.row, move.column).has(Marking.CHECK_LINE)
                && !gameBoard.markings.get(move.row, move.column).has(Marking.CHECK_ORIGIN)) return;

            // If we're only counting moves, we don't need to remember which moves were the valid ones
            if (gameBoard.phase === Phase.COUNT_MOVES) {
                gameBoard.availableMoves++;
            } else {
                gameBoard.markings.get(move.row, move.column).add(Marking.VALID);
            }

            break;
        }

        case Phase.ATTACK:    {
            // Attacking/defending pieces is way more lenient, no conditions!
            gameBoard.markings.get(move.row, move.column).add(Marking.ATTACKED);

            // Check for attacks on the king, to remember which pieces and how many are checking the king
            let piece = gameBoard.getPiece(move);
            if (piece !== null && piece.isOpponentKing(move)) {
                gameBoard.checkCount++;
                traceState.checkOrigin = true; // Remember we are attacking the King so we can trace back our path

                gameBoard.markings.get(move.pieceRow, move.pieceColumn).add(Marking.CHECK_ORIGIN);

                // Edge Case Nr.1: 'En Passant Check'
                // If a pawn attacking the king just did a double move, we could defend against this
                // by capturing the pawn via En Passant, if possible
                if (move.type === Type.PAWN) {
                    const checkingPawn = gameBoard.getPiece(new Position(move.pieceRow, move.pieceColumn));
                    if (checkingPawn != null) {
                        const behind = checkingPawn.behind();
                        gameBoard.markings.get(behind.row, behind.column).add(Marking.CHECK_LINE);
                    }
                }
            }

            break;
        }
    }
}

Game flow

// Scroll + 🖱️ to pan sideways →

// The function that is called the moment a piece is selected/lifted.
// Shows the valid move for the selected piece
export function selectPiece(piece: Piece) {
    clearMarkings([Marking.VALID]);

    gameBoard.phase = Phase.VALIDATE_MOVES;
    runValidation([ piece ]);
}

// The function that is called the moment a piece is dropped, or a destination square
// was selected. Will only move if this position was marked as valid in selectPiece()
export function movePiece(piece: Piece, position: Position) {
    const markings = gameBoard.markings.get(position.row, position.column);

    // Validate move
    if (!markings.has(Marking.VALID)) {
        clearMarkings([Marking.VALID]);
        return;
    }

    // This is set by this same function further down, thus from a previous call.
    // Whether the current move we're verifying is a capture via En Passant
    const isEnPassantCapture = piece.type === Type.PAWN && markings.has(Marking.EN_PASSANTABLE);

    // Reset things we have remembered about the board, so we have a clean slate to recompute everything
    gameBoard.checkCount = 0;
    clearMarkings([
        Marking.VALID,
        Marking.ATTACKED,
        Marking.CHECK_LINE,
        Marking.CHECK_ORIGIN,
        Marking.LATEST_MOVE,
        Marking.PINNED,
        Marking.EN_PASSANTABLE,
        Marking.PSEUDO_PINNED,
    ]);

    // En Passant capture. Since we're not just capturing on the same square we're moving to, we have
    // to remove the En Passantable pawn manually, here by sampling the current row and new column
    if (isEnPassantCapture)
        gameBoard.pieces.set(piece.row, position.column, null);

    gameBoard.pieces.set(piece.row, piece.column, null); // Leave a void behind on the square we left
    const movedPiece = piece.move(position.row, position.column);
    gameBoard.pieces.set(position.row, position.column, movedPiece);

    // Castling: Simply detected here as the King making a double move, which we follow up by the Rook in
    // that direction moving over to the other side of the King
    if (piece.type === Type.KING && Math.abs(position.column - piece.column) === 2) {
        const direction = Math.sign(position.column - piece.column);
        const rook = findRookForCastle(movedPiece, direction);

        if (rook != null) {
            gameBoard.pieces.set(rook.row, rook.column, null);
            const rookDestination = movedPiece.offset(0, -direction);
            gameBoard.pieces.set(rookDestination.row, rookDestination.column, rook.move(rookDestination.row, rookDestination.column));
        }
    }

    // En Passant: If the pawn just made a double move, we can mark it as En Passantable for now,
    // which will automatically be cleared if the opportunity is ignored
    if (piece.type === Type.PAWN && Math.abs(position.row - piece.row) === 2) {
        const skipped = piece.inFront();
        gameBoard.markings.get(skipped.row, skipped.column).add(Marking.EN_PASSANTABLE);
        gameBoard.markings.get(position.row, position.column).add(Marking.EN_PASSANTABLE);
    }

    gameBoard.markings.get(position.row, position.column).add(Marking.LATEST_MOVE);

    // Promotion: We can easily check whether the pawn has reached the back rank by seeing if the
    // position in front of it is off the board. In that case, we switch to a promoting state, as
    // it is mandatory for the current player to choose a promotion. This prevents the post-move
    // code from running now. It will run once the player has promoted, on an updated board
    if (movedPiece.type === Type.PAWN && !movedPiece.inFront().onBoard()) {
        gameBoard.phase = Phase.PROMOTING;
        gameBoard.promotingPiece = movedPiece;
        return;
    }

    postMove();
}

// The function that is called after a move was made, to prepare the board for the move of the
// next player. This does most of the square marking.
export function postMove() {

    // For all pieces of the current color, scan what squares they are defending now
    gameBoard.phase = Phase.ATTACK;
    runValidation(getPiecesByColor(gameBoard.currentTurn));

    // Count how many valid moves the pieces of the other color can make, combined
    gameBoard.availableMoves = 0;
    gameBoard.phase = Phase.COUNT_MOVES;
    runValidation(getPiecesByColor(otherColor(gameBoard.currentTurn)));

    if (checkGameOver()) return;

    // Ready for the next move
    gameBoard.currentTurn = otherColor(gameBoard.currentTurn);
    gameBoard.phase = Phase.IDLE;
}

// Run the validation code for a set of pieces at the same time
export function runValidation(pieces: Piece[]) {
    for (let piece of pieces) {

        if (piece.type === Type.KNIGHT)  knightMoves(piece);
        if (piece.type === Type.ROOK)    rookMoves(piece);
        if (piece.type === Type.BISHOP)  bishopMoves(piece);
        if (piece.type === Type.QUEEN)   queenMoves(piece);
        if (piece.type === Type.PAWN)    pawnMoves(piece);
        if (piece.type === Type.KING)    kingMoves(piece);
    }
}

Not so interesting

Implementation Details / API

// Scroll + 🖱️ to pan sideways →

// This contains all the underlying data structures and utility classes/functions
// Useful to refer to when unsure about a certain functionality

// Utility class for storing positions without any information
// regarding a potential piece occupying it
export class Position {
    constructor(
        public row: number,
        public column: number,
    ) {};

    // Parse from a string, eg. "11"
    static parse(str: string) {
        return new Position(Number((str as any)[0]), Number((str as any)[1]));
    }

    toString(): string {
        return `${this.row}${this.column}`;
    }

    onBoard() {
        return 0 < this.row && this.row < 9 && 0 < this.column && this.column < 9;
    }

    manhattanDist(row: number, column: number): number {
        return Math.abs(this.row - row) + Math.abs(this.column - column);
    }
}

// Enums for easy property access and comparison between pieces
export enum Type {
    PAWN = 'pawn',
    KNIGHT = 'knight',
    BISHOP = 'bishop',
    ROOK = 'rook',
    QUEEN = 'queen',
    KING = 'king',
}

export enum Color {
    WHITE = 'white',
    BLACK = 'black',
}

// Simply flip the color. White -> Black - Black -> White
export function otherColor(color: Color) {
    return color == Color.WHITE ? Color.BLACK : Color.WHITE;
}

// Types of marking a square can have
export enum Marking {
    VALID = 'mark-valid',
    ATTACKED = 'mark-attacked',
    CHECK_LINE = 'mark-line-of-check',
    CHECK_ORIGIN = 'mark-check-origin',
    LATEST_MOVE = 'mark-last-move',
    PINNED = 'mark-pinned',
    EN_PASSANTABLE = 'mark-en-passantable',
    PSEUDO_PINNED = 'mark-pseudo-pinned',
}

// For parsing eg. "p-w:11"
const TYPE_CHARS: Record<string, Type> = {
    p: Type.PAWN,
    n: Type.KNIGHT,
    b: Type.BISHOP,
    r: Type.ROOK,
    q: Type.QUEEN,
    k: Type.KING,
};

const COLOR_CHARS: Record<string, Color> = {
    w: Color.WHITE,
    b: Color.BLACK,
};

// An extended utility class to store a Piece as well as its position, and a
// position to navigate while still having easy access to the Piece's properties
export class Piece extends Position {
    public type: Type;
    public color: Color;
    public hasMoved: boolean;

    // These two always represent the actual position of the piece we're working with
    public pieceRow: number;
    public pieceColumn: number;

    constructor(type: Type, color: Color, row: number, column: number, pieceRow: number, pieceColumn: number, hasMoved: boolean) {
        super(row, column);
        this.type = type;
        this.color = color;
        this.hasMoved = hasMoved;

        this.pieceRow = pieceRow;
        this.pieceColumn = pieceColumn;
    }

    // Parse from eg. "p-w:11"
    static parsePiece(str: string): Piece | null {
        if (str == '') return null;

        const [typeColor, position] = str.split(':');
        const [type, color] = typeColor.split('-');
        const pos = Position.parse(position);

        return new Piece(TYPE_CHARS[type], COLOR_CHARS[color], pos.row, pos.column, pos.row, pos.column, false);
    }

    move(row: number, column: number): Piece {
        return new Piece(this.type, this.color, row, column, row, column, true);
    }

    offset(row: number, column: number): Piece {
        return new Piece(this.type, this.color, row + this.row, column + this.column, this.pieceRow, this.pieceColumn, this.hasMoved);
    }

    // One square away from that color's back rank.
    // Comparable to methods below
    inFront() {
        return this.offset(this.color === Color.WHITE ? 1 : -1, 0);
    }

    behind() {
        return this.offset(this.color === Color.WHITE ? -1 : 1, 0);
    }

    left() {
        return this.offset(0, this.color === Color.WHITE ? 1 : -1);
    }

    right() {
        return this.offset(0, this.color === Color.WHITE ? -1 : 1);
    }

    // Simply returns whether THIS is the opposing king of a certain piece
    isOpponentKing(piece: Piece) {
        return this.type === Type.KING && this.color !== piece.color;
    }
}

// Starting position:
// Row 1 = white's back rank
// Row 8 = black's back rank
let STARTING_POSITION: string[][] = [
    ['r-w', 'n-w', 'b-w', 'q-w', 'k-w', 'b-w', 'n-w', 'r-w'],
    ['p-w', 'p-w', 'p-w', 'p-w', 'p-w', 'p-w', 'p-w', 'p-w'],
    ['', '', '', '', '', '', '', ''],
    ['', '', '', '', '', '', '', ''],
    ['', '', '', '', '', '', '', ''],
    ['', '', '', '', '', '', '', ''],
    ['p-b', 'p-b', 'p-b', 'p-b', 'p-b', 'p-b', 'p-b', 'p-b'],
    ['r-b', 'n-b', 'b-b', 'q-b', 'k-b', 'b-b', 'n-b', 'r-b'],
];


// 1-indexed 2-dimensional matrix
export class Matrix<T> {
    constructor(
        private values: T[][],
    ) {}

    getPos(position: Position) {
        return this.values[position.row - 1][position.column - 1];
    }

    get(row: number, column: number) {
        return this.values[row - 1][column - 1];
    }

    set(row: number, column: number, value: T) {
        this.values[row - 1][column - 1] = value;
    }
}

export enum Phase {
    VALIDATE_MOVES,
    ATTACK,
    COUNT_MOVES,
    PROMOTING,
    IDLE,
    OVER,
}

export class Board {
    public pieces: Matrix<Piece | null> = new Matrix(STARTING_POSITION.map((row, i) => row.map((s, j) => Piece.parsePiece(s == '' ? '' : `${s}:${i + 1}${j + 1}`))) );

    public markings: Matrix<Set<string>> = new Matrix(STARTING_POSITION.map(row => row.map(() => new Set<string>())) );

    public phase: Phase = Phase.VALIDATE_MOVES;
    public currentTurn: Color = Color.WHITE;

    public checkCount: number = 0;
    public availableMoves: number = 0;
    public promotingPiece: Piece | null = null;

    getPiece(position: Position): Piece | null {
        return this.pieces.get(position.row, position.column);
    }
}

export const gameBoard = new Board();

// Check whether a certain position has a piece friendly to the current piece.
export function hasFriendlyPiece(move: Piece) {
    if (!move.onBoard()) return;
    const piece = gameBoard.getPiece(move);

    return piece != null && piece.color === move.color;
}

// Check whether a certain position has a piece offensive to the current piece.
export function hasEnemyPiece(move: Piece) {
    if (!move.onBoard()) return;
    const piece = gameBoard.getPiece(move);

    return piece != null && piece.color !== move.color;
}

// Check whether a certain position has a piece
export function hasPiece(move: Piece) {
    if (!move.onBoard()) return;
    const piece = gameBoard.getPiece(move);

    return piece != null;
}

// Check whether a certain position is marked en-passantable (see movePiece, which sets this
// for exactly one enemy turn whenever a pawn double-moves)
export function isEnPassantable(move: Piece) {
    if (!move.onBoard()) return false;

    return gameBoard.markings.get(move.row, move.column).has(Marking.EN_PASSANTABLE);
}

// Returns the king of the given color
export function getKing(color: Color): Piece {
    return getPiecesByColor(color).find(p => p.type === Type.KING)!;
}

// Returns every piece of the given color still on the board
export function getPiecesByColor(color: Color): Piece[] {
    const pieces: Piece[] = [];

    for (let row = 1; row <= 8; row++)
        for (let column = 1; column <= 8; column++) {
            const piece = gameBoard.getPiece(new Position(row, column));
            if (piece != null && piece.color === color) pieces.push(piece);
        }

    return pieces;
}

// Clears certain markings from every square
export function clearMarkings(markings: Marking[]) {
    for (let row = 1; row < 9; row++)
        for (let column = 1; column < 9; column++)
            for (let marking of markings)
                gameBoard.markings.get(row, column).delete(marking);
}

Test Configurations

// Scroll + 🖱️ to pan sideways →

export let TEST_NORMAL_BOARD = [
    ['r-w', 'n-w', 'b-w', 'q-w', 'k-w', 'b-w', 'n-w', 'r-w'],
    ['p-w', 'p-w', 'p-w', 'p-w', 'p-w', 'p-w', 'p-w', 'p-w'],
    ['',    '',    '',    '',    '',    '',    '',    ''   ],
    ['',    '',    '',    '',    '',    '',    '',    ''   ],
    ['',    '',    '',    '',    '',    '',    '',    ''   ],
    ['',    '',    '',    '',    '',    '',    '',    ''   ],
    ['p-b', 'p-b', 'p-b', 'p-b', 'p-b', 'p-b', 'p-b', 'p-b'],
    ['r-b', 'n-b', 'b-b', 'q-b', 'k-b', 'b-b', 'n-b', 'r-b'],
];

export let TEST_KINGS_AND_ROOKS = [
    ['r-w', '',   '',   '',   'k-w', '',   '',   'r-w'],
    ['',    '',   '',   '',   '',    '',   '',   ''   ],
    ['',    '',   '',   '',   '',    '',   '',   ''   ],
    ['',    '',   '',   '',   '',    '',   '',   ''   ],
    ['',    '',   '',   '',   '',    '',   '',   ''   ],
    ['',    '',   '',   '',   '',    '',   '',   ''   ],
    ['',    '',   '',   '',   '',    '',   '',   ''   ],
    ['r-b', '',   '',   '',   'k-b', '',   '',   'r-b'],
];

export let TEST_DOUBLE_CHECK = [
    [ '',    '',    '',    '',    '',    '',    '',   'k-w'],
    [ '',   'k-b',  '',    '',    '',    '',   'r-b',  ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',   'n-b',  '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',   'r-w',  '',    ''  ],
    [ '',    '',    '',    '',    '',    '',   'b-w',  ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
];

export let TEST_NO_PAWNS = [
    ['r-w', 'n-w', 'b-w', 'q-w', 'k-w', 'b-w', 'n-w', 'r-w'],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    ['r-b', 'n-b', 'b-b', 'q-b', 'k-b', 'b-b', 'n-b', 'r-b'],
];

// En Passant check demo: After double moving the white pawn, capturing via En Passant
// would free the King from check, despite this not being a move to the position of the
// origin of the check, nor a position in between the king and it
export let TEST_EN_PASSANT_CHECK = [
    ['k-w',  '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',   'p-w',  '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',   'p-b',  ''  ],
    [ '',    '',    '',    '',   'k-b',  '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
];

// En Passant pseudo-pin demo. After double moving the white pawn, capturing via En Passant
// would result in exposing the king, even though no pieces are pinned
export let TEST_EN_PASSANT_PSEUDO_PIN = [
    [ '',    '',    '',    '',    '',    '',    '',   'k-w'],
    [ '',    '',   'p-w',  '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    ['r-w',  '',    '',   'p-b',  '',   'k-b',  '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
    [ '',    '',    '',    '',    '',    '',    '',    ''  ],
];

// Loads a test configuration onto a fresh board, then runs the necessary computations
export function loadConfiguration(config: string[][]) {
    loadPosition(config);
    resetGameOver();

    // ATTACK phase belongs to whoever ISN'T about to move, compute
    // Black's attack squares to let them influence white's move
    gameBoard.currentTurn = Color.BLACK;

    postMove();
}

// Replaces all parts of the board to swap it for a different position
export function loadPosition(config: string[][]) {
    for (let row = 1; row <= 8; row++)
        for (let column = 1; column <= 8; column++) {
            const cell = config[row - 1]?.[column - 1] ?? '';
            gameBoard.pieces.set(row, column, Piece.parsePiece(cell === '' ? '' : `${cell}:${row}${column}`));
            gameBoard.markings.set(row, column, new Set());
        }

    gameBoard.phase = Phase.VALIDATE_MOVES;
    gameBoard.currentTurn = Color.WHITE;
    gameBoard.checkCount = 0;
    gameBoard.availableMoves = 0;
    gameBoard.promotingPiece = null;
}

Load a Test Configuration

Normal Setup

Castling

Double Check

No Pawns

En Passant Check

En Passant Pseudo-pin