Add chess/shared/chess-engine.js

chess/shared/chess-engine.js

@@ -0,0 +1,824 @@
+//chess-engine.js
+
+const FILES = "abcdefgh";
+const STARTING_BACK_RANK = ["R", "N", "B", "Q", "K", "B", "N", "R"];
+
+function createPiece(color, type) {
+  return { color, type };
+}
+
+function clonePiece(piece) {
+  return piece ? { color: piece.color, type: piece.type } : null;
+}
+
+function cloneBoard(board) {
+  return board.map((row) => row.map((piece) => clonePiece(piece)));
+}
+
+function colorLabel(color) {
+  return color === "w" ? "White" : "Black";
+}
+
+export function opponentColor(color) {
+  return color === "w" ? "b" : "w";
+}
+
+export function toSquare(x, y) {
+  return `${FILES[x]}${8 - y}`;
+}
+
+export function fromSquare(square) {
+  if (!square || square.length !== 2) {
+    return null;
+  }
+
+  const file = square[0].toLowerCase();
+  const rank = Number(square[1]);
+  const x = FILES.indexOf(file);
+  const y = 8 - rank;
+
+  if (x < 0 || Number.isNaN(y) || y < 0 || y > 7) {
+    return null;
+  }
+
+  return { x, y };
+}
+
+function inBounds(x, y) {
+  return x >= 0 && x < 8 && y >= 0 && y < 8;
+}
+
+function createEmptyBoard() {
+  return Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => null));
+}
+
+function createStartingBoard() {
+  const board = createEmptyBoard();
+
+  for (let index = 0; index < 8; index += 1) {
+    board[0][index] = createPiece("b", STARTING_BACK_RANK[index]);
+    board[1][index] = createPiece("b", "P");
+    board[6][index] = createPiece("w", "P");
+    board[7][index] = createPiece("w", STARTING_BACK_RANK[index]);
+  }
+
+  return board;
+}
+
+function createCastlingRights() {
+  return {
+    w: { k: true, q: true },
+    b: { k: true, q: true },
+  };
+}
+
+function createInitialState() {
+  return {
+    board: createStartingBoard(),
+    turn: "w",
+    castling: createCastlingRights(),
+    enPassant: null,
+    halfmoveClock: 0,
+    fullmoveNumber: 1,
+    history: [],
+    positionCounts: {},
+    status: null,
+    lastMove: null,
+  };
+}
+
+function cloneState(state) {
+  return {
+    board: cloneBoard(state.board),
+    turn: state.turn,
+    castling: {
+      w: { ...state.castling.w },
+      b: { ...state.castling.b },
+    },
+    enPassant: state.enPassant,
+    halfmoveClock: state.halfmoveClock,
+    fullmoveNumber: state.fullmoveNumber,
+    history: state.history.map((entry) => ({ ...entry })),
+    positionCounts: { ...state.positionCounts },
+    status: state.status ? { ...state.status } : null,
+    lastMove: state.lastMove ? { ...state.lastMove } : null,
+  };
+}
+
+function boardToHash(board) {
+  return board
+    .map((row) =>
+      row
+        .map((piece) => {
+          if (!piece) {
+            return ".";
+          }
+
+          return piece.color === "w" ? piece.type : piece.type.toLowerCase();
+        })
+        .join(""),
+    )
+    .join("/");
+}
+
+function positionHash(state) {
+  const castlingText = ["w", "b"]
+    .map((color) => {
+      const rights = [];
+      if (state.castling[color].k) {
+        rights.push("k");
+      }
+      if (state.castling[color].q) {
+        rights.push("q");
+      }
+      return rights.length ? rights.join("") : "-";
+    })
+    .join("");
+
+  return [
+    boardToHash(state.board),
+    state.turn,
+    castlingText || "-",
+    state.enPassant || "-",
+  ].join("|");
+}
+
+function addPositionCount(state) {
+  const hash = positionHash(state);
+  state.positionCounts[hash] = (state.positionCounts[hash] || 0) + 1;
+}
+
+function pieceAt(board, x, y) {
+  if (!inBounds(x, y)) {
+    return null;
+  }
+  return board[y][x];
+}
+
+function setPiece(board, x, y, piece) {
+  board[y][x] = piece;
+}
+
+function squareColor(x, y) {
+  return (x + y) % 2 === 0 ? "dark" : "light";
+}
+
+function getKingPosition(board, color) {
+  for (let y = 0; y < 8; y += 1) {
+    for (let x = 0; x < 8; x += 1) {
+      const piece = board[y][x];
+      if (piece && piece.color === color && piece.type === "K") {
+        return { x, y };
+      }
+    }
+  }
+
+  return null;
+}
+
+function isSquareAttacked(state, x, y, byColor) {
+  const board = state.board;
+  const pawnOffset = byColor === "w" ? 1 : -1;
+
+  for (const dx of [-1, 1]) {
+    const piece = pieceAt(board, x + dx, y + pawnOffset);
+    if (piece && piece.color === byColor && piece.type === "P") {
+      return true;
+    }
+  }
+
+  const knightOffsets = [
+    [-2, -1],
+    [-2, 1],
+    [-1, -2],
+    [-1, 2],
+    [1, -2],
+    [1, 2],
+    [2, -1],
+    [2, 1],
+  ];
+
+  for (const [dx, dy] of knightOffsets) {
+    const piece = pieceAt(board, x + dx, y + dy);
+    if (piece && piece.color === byColor && piece.type === "N") {
+      return true;
+    }
+  }
+
+  const slidingLines = [
+    { directions: [[1, 0], [-1, 0], [0, 1], [0, -1]], pieces: ["R", "Q"] },
+    { directions: [[1, 1], [1, -1], [-1, 1], [-1, -1]], pieces: ["B", "Q"] },
+  ];
+
+  for (const line of slidingLines) {
+    for (const [dx, dy] of line.directions) {
+      let nx = x + dx;
+      let ny = y + dy;
+
+      while (inBounds(nx, ny)) {
+        const piece = pieceAt(board, nx, ny);
+        if (piece) {
+          if (piece.color === byColor && line.pieces.includes(piece.type)) {
+            return true;
+          }
+          break;
+        }
+        nx += dx;
+        ny += dy;
+      }
+    }
+  }
+
+  for (let dy = -1; dy <= 1; dy += 1) {
+    for (let dx = -1; dx <= 1; dx += 1) {
+      if (dx === 0 && dy === 0) {
+        continue;
+      }
+      const piece = pieceAt(board, x + dx, y + dy);
+      if (piece && piece.color === byColor && piece.type === "K") {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function isInCheck(state, color) {
+  const king = getKingPosition(state.board, color);
+  if (!king) {
+    return false;
+  }
+  return isSquareAttacked(state, king.x, king.y, opponentColor(color));
+}
+
+function addMove(moves, state, x, y, nx, ny, extras = {}) {
+  if (!inBounds(nx, ny)) {
+    return;
+  }
+
+  const piece = state.board[y][x];
+  const target = state.board[ny][nx];
+
+  if (target && target.color === piece.color) {
+    return;
+  }
+
+  moves.push({
+    from: toSquare(x, y),
+    to: toSquare(nx, ny),
+    fromX: x,
+    fromY: y,
+    toX: nx,
+    toY: ny,
+    color: piece.color,
+    piece: piece.type,
+    capture: target ? target.type : extras.capture || null,
+    captureColor: target ? target.color : extras.captureColor || null,
+    promotion: extras.promotion || null,
+    castle: extras.castle || null,
+    enPassant: Boolean(extras.enPassant),
+    doublePawnPush: Boolean(extras.doublePawnPush),
+  });
+}
+
+function generatePawnMoves(state, x, y, piece, moves) {
+  const direction = piece.color === "w" ? -1 : 1;
+  const startRow = piece.color === "w" ? 6 : 1;
+  const promotionRow = piece.color === "w" ? 0 : 7;
+  const forwardY = y + direction;
+
+  if (inBounds(x, forwardY) && !pieceAt(state.board, x, forwardY)) {
+    if (forwardY === promotionRow) {
+      for (const promotion of ["q", "r", "b", "n"]) {
+        addMove(moves, state, x, y, x, forwardY, { promotion });
+      }
+    } else {
+      addMove(moves, state, x, y, x, forwardY);
+    }
+
+    const doubleForwardY = y + direction * 2;
+    if (y === startRow && !pieceAt(state.board, x, doubleForwardY)) {
+      addMove(moves, state, x, y, x, doubleForwardY, { doublePawnPush: true });
+    }
+  }
+
+  for (const dx of [-1, 1]) {
+    const nx = x + dx;
+    const ny = y + direction;
+    if (!inBounds(nx, ny)) {
+      continue;
+    }
+
+    const target = pieceAt(state.board, nx, ny);
+    if (target && target.color !== piece.color) {
+      if (ny === promotionRow) {
+        for (const promotion of ["q", "r", "b", "n"]) {
+          addMove(moves, state, x, y, nx, ny, { promotion });
+        }
+      } else {
+        addMove(moves, state, x, y, nx, ny);
+      }
+      continue;
+    }
+
+    if (state.enPassant === toSquare(nx, ny)) {
+      const capturedPawn = pieceAt(state.board, nx, y);
+      if (capturedPawn && capturedPawn.color !== piece.color && capturedPawn.type === "P") {
+        addMove(moves, state, x, y, nx, ny, {
+          enPassant: true,
+          capture: "P",
+          captureColor: capturedPawn.color,
+        });
+      }
+    }
+  }
+}
+
+function generateSlidingMoves(state, x, y, moves, directions) {
+  for (const [dx, dy] of directions) {
+    let nx = x + dx;
+    let ny = y + dy;
+
+    while (inBounds(nx, ny)) {
+      const target = pieceAt(state.board, nx, ny);
+      if (!target) {
+        addMove(moves, state, x, y, nx, ny);
+      } else {
+        if (target.color !== state.board[y][x].color) {
+          addMove(moves, state, x, y, nx, ny);
+        }
+        break;
+      }
+
+      nx += dx;
+      ny += dy;
+    }
+  }
+}
+
+function canCastle(state, color, side) {
+  const homeRank = color === "w" ? 7 : 0;
+  const rookFile = side === "k" ? 7 : 0;
+  const king = pieceAt(state.board, 4, homeRank);
+  const rook = pieceAt(state.board, rookFile, homeRank);
+
+  if (!king || king.type !== "K" || king.color !== color) {
+    return false;
+  }
+  if (!rook || rook.type !== "R" || rook.color !== color) {
+    return false;
+  }
+  if (!state.castling[color][side] || isInCheck(state, color)) {
+    return false;
+  }
+
+  const betweenSquares = side === "k" ? [5, 6] : [1, 2, 3];
+  for (const file of betweenSquares) {
+    if (pieceAt(state.board, file, homeRank)) {
+      return false;
+    }
+  }
+
+  const traverseSquares = side === "k" ? [5, 6] : [3, 2];
+  for (const file of traverseSquares) {
+    if (isSquareAttacked(state, file, homeRank, opponentColor(color))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function generateKingMoves(state, x, y, piece, moves) {
+  for (let dy = -1; dy <= 1; dy += 1) {
+    for (let dx = -1; dx <= 1; dx += 1) {
+      if (dx === 0 && dy === 0) {
+        continue;
+      }
+      addMove(moves, state, x, y, x + dx, y + dy);
+    }
+  }
+
+  if (canCastle(state, piece.color, "k")) {
+    addMove(moves, state, x, y, x + 2, y, { castle: "k" });
+  }
+
+  if (canCastle(state, piece.color, "q")) {
+    addMove(moves, state, x, y, x - 2, y, { castle: "q" });
+  }
+}
+
+function generatePseudoMoves(state, x, y) {
+  const piece = pieceAt(state.board, x, y);
+  if (!piece) {
+    return [];
+  }
+
+  const moves = [];
+
+  if (piece.type === "P") {
+    generatePawnMoves(state, x, y, piece, moves);
+  } else if (piece.type === "N") {
+    const offsets = [
+      [-2, -1],
+      [-2, 1],
+      [-1, -2],
+      [-1, 2],
+      [1, -2],
+      [1, 2],
+      [2, -1],
+      [2, 1],
+    ];
+    for (const [dx, dy] of offsets) {
+      addMove(moves, state, x, y, x + dx, y + dy);
+    }
+  } else if (piece.type === "B") {
+    generateSlidingMoves(state, x, y, moves, [
+      [1, 1],
+      [1, -1],
+      [-1, 1],
+      [-1, -1],
+    ]);
+  } else if (piece.type === "R") {
+    generateSlidingMoves(state, x, y, moves, [
+      [1, 0],
+      [-1, 0],
+      [0, 1],
+      [0, -1],
+    ]);
+  } else if (piece.type === "Q") {
+    generateSlidingMoves(state, x, y, moves, [
+      [1, 0],
+      [-1, 0],
+      [0, 1],
+      [0, -1],
+      [1, 1],
+      [1, -1],
+      [-1, 1],
+      [-1, -1],
+    ]);
+  } else if (piece.type === "K") {
+    generateKingMoves(state, x, y, piece, moves);
+  }
+
+  return moves;
+}
+
+function updateCastlingRights(nextState, move) {
+  const { color, piece, from, to, capture, captureColor } = move;
+
+  if (piece === "K") {
+    nextState.castling[color].k = false;
+    nextState.castling[color].q = false;
+  }
+
+  if (piece === "R") {
+    if (from === "a1") {
+      nextState.castling.w.q = false;
+    }
+    if (from === "h1") {
+      nextState.castling.w.k = false;
+    }
+    if (from === "a8") {
+      nextState.castling.b.q = false;
+    }
+    if (from === "h8") {
+      nextState.castling.b.k = false;
+    }
+  }
+
+  if (capture === "R" && captureColor) {
+    if (to === "a1") {
+      nextState.castling.w.q = false;
+    }
+    if (to === "h1") {
+      nextState.castling.w.k = false;
+    }
+    if (to === "a8") {
+      nextState.castling.b.q = false;
+    }
+    if (to === "h8") {
+      nextState.castling.b.k = false;
+    }
+  }
+}
+
+function buildMoveNotation(move, status) {
+  if (move.castle === "k") {
+    return status.reason === "checkmate" ? "O-O#" : status.check ? "O-O+" : "O-O";
+  }
+
+  if (move.castle === "q") {
+    return status.reason === "checkmate" ? "O-O-O#" : status.check ? "O-O-O+" : "O-O-O";
+  }
+
+  const piecePrefix = move.piece === "P" ? "" : move.piece;
+  const pawnCapturePrefix = move.piece === "P" && move.capture ? move.from[0] : "";
+  const captureMarker = move.capture ? "x" : "";
+  const promotionText = move.promotion ? `=${move.promotion.toUpperCase()}` : "";
+  const suffix = status.reason === "checkmate" ? "#" : status.check ? "+" : "";
+
+  return `${piecePrefix}${pawnCapturePrefix}${captureMarker}${move.to}${promotionText}${suffix}`;
+}
+
+function getMoveRecord(move, status, nextState) {
+  return {
+    from: move.from,
+    to: move.to,
+    color: move.color,
+    piece: move.piece,
+    capture: move.capture,
+    promotion: move.promotion,
+    castle: move.castle,
+    enPassant: move.enPassant,
+    notation: buildMoveNotation(move, status),
+    turnNumber: nextState.fullmoveNumber - (move.color === "w" ? 0 : 1),
+    fenKey: positionHash(nextState),
+  };
+}
+
+function hasInsufficientMaterial(board) {
+  const pieces = [];
+
+  for (const row of board) {
+    for (const piece of row) {
+      if (piece) {
+        pieces.push(piece);
+      }
+    }
+  }
+
+  const nonKings = pieces.filter((piece) => piece.type !== "K");
+  if (nonKings.some((piece) => ["P", "R", "Q"].includes(piece.type))) {
+    return false;
+  }
+
+  if (nonKings.length === 0 || nonKings.length === 1) {
+    return true;
+  }
+
+  if (nonKings.length === 2) {
+    const [first, second] = nonKings;
+    if (first.color !== second.color) {
+      return true;
+    }
+    if (first.type === "N" && second.type === "N") {
+      return true;
+    }
+  }
+
+  const bishops = [];
+  for (let y = 0; y < 8; y += 1) {
+    for (let x = 0; x < 8; x += 1) {
+      const piece = board[y][x];
+      if (piece && piece.type === "B") {
+        bishops.push({ ...piece, x, y });
+      }
+    }
+  }
+
+  if (nonKings.length === 2 && bishops.length === 2 && bishops[0].color !== bishops[1].color) {
+    return squareColor(bishops[0].x, bishops[0].y) === squareColor(bishops[1].x, bishops[1].y);
+  }
+
+  return false;
+}
+
+function evaluateStatus(state) {
+  const legalMoves = ChessEngine.generateLegalMovesForState(state, state.turn);
+  const check = isInCheck(state, state.turn);
+  const repetitionCount = state.positionCounts[positionHash(state)] || 0;
+
+  const status = {
+    phase: "playing",
+    winner: null,
+    reason: null,
+    check,
+    legalMoves: legalMoves.length,
+    message: `${colorLabel(state.turn)} to move.`,
+  };
+
+  if (legalMoves.length === 0) {
+    if (check) {
+      status.phase = "checkmate";
+      status.reason = "checkmate";
+      status.winner = opponentColor(state.turn);
+      status.message = `${colorLabel(status.winner)} wins by checkmate.`;
+    } else {
+      status.phase = "draw";
+      status.reason = "stalemate";
+      status.message = "Draw by stalemate.";
+    }
+    return status;
+  }
+
+  if (hasInsufficientMaterial(state.board)) {
+    status.phase = "draw";
+    status.reason = "insufficient-material";
+    status.message = "Draw by insufficient material.";
+    return status;
+  }
+
+  if (state.halfmoveClock >= 100) {
+    status.phase = "draw";
+    status.reason = "fifty-move";
+    status.message = "Draw by fifty-move rule.";
+    return status;
+  }
+
+  if (repetitionCount >= 3) {
+    status.phase = "draw";
+    status.reason = "threefold";
+    status.message = "Draw by threefold repetition.";
+    return status;
+  }
+
+  if (check) {
+    status.message = `${colorLabel(state.turn)} to move. Check.`;
+  }
+
+  return status;
+}
+
+function applyMoveToState(state, move, options = {}) {
+  const {
+    recordHistory = false,
+    computeStatus = true,
+    updatePositionCounts = computeStatus || recordHistory,
+  } = options;
+  const nextState = cloneState(state);
+  const movingPiece = pieceAt(nextState.board, move.fromX, move.fromY);
+
+  if (!movingPiece) {
+    throw new Error("No piece found on source square.");
+  }
+
+  setPiece(nextState.board, move.fromX, move.fromY, null);
+
+  if (move.enPassant) {
+    setPiece(nextState.board, move.toX, move.fromY, null);
+  }
+
+  const placedPiece = createPiece(
+    movingPiece.color,
+    move.promotion ? move.promotion.toUpperCase() : movingPiece.type,
+  );
+  setPiece(nextState.board, move.toX, move.toY, placedPiece);
+
+  if (move.castle === "k") {
+    const rook = pieceAt(nextState.board, 7, move.fromY);
+    setPiece(nextState.board, 7, move.fromY, null);
+    setPiece(nextState.board, 5, move.fromY, rook);
+  } else if (move.castle === "q") {
+    const rook = pieceAt(nextState.board, 0, move.fromY);
+    setPiece(nextState.board, 0, move.fromY, null);
+    setPiece(nextState.board, 3, move.fromY, rook);
+  }
+
+  updateCastlingRights(nextState, move);
+
+  nextState.enPassant = move.doublePawnPush ? toSquare(move.fromX, (move.fromY + move.toY) / 2) : null;
+  nextState.halfmoveClock = move.piece === "P" || move.capture ? 0 : nextState.halfmoveClock + 1;
+  nextState.turn = opponentColor(state.turn);
+
+  if (move.color === "b") {
+    nextState.fullmoveNumber += 1;
+  }
+
+  nextState.lastMove = {
+    from: move.from,
+    to: move.to,
+    color: move.color,
+  };
+
+  if (updatePositionCounts) {
+    addPositionCount(nextState);
+  }
+  nextState.status = computeStatus ? evaluateStatus(nextState) : null;
+
+  if (recordHistory) {
+    nextState.history.push(getMoveRecord(move, nextState.status, nextState));
+  }
+
+  return nextState;
+}
+
+export class ChessEngine {
+  constructor(snapshot = null) {
+    this.state = snapshot ? cloneState(snapshot) : createInitialState();
+    if (Object.keys(this.state.positionCounts).length === 0) {
+      addPositionCount(this.state);
+    }
+    this.state.status = evaluateStatus(this.state);
+  }
+
+  reset() {
+    this.state = createInitialState();
+    addPositionCount(this.state);
+    this.state.status = evaluateStatus(this.state);
+    return this.getSnapshot();
+  }
+
+  getSnapshot() {
+    return cloneState(this.state);
+  }
+
+  getPiece(square) {
+    const coords = fromSquare(square);
+    if (!coords) {
+      return null;
+    }
+    return clonePiece(pieceAt(this.state.board, coords.x, coords.y));
+  }
+
+  getMovesFrom(square) {
+    return this.getLegalMoves(this.state.turn).filter((move) => move.from === square);
+  }
+
+  getLegalMoves(color = this.state.turn) {
+    return ChessEngine.generateLegalMovesForState(this.state, color);
+  }
+
+  makeMove(input) {
+    const legalMove = ChessEngine.findLegalMove(this.state, input);
+    if (!legalMove) {
+      return {
+        ok: false,
+        error: "Illegal move.",
+        state: this.getSnapshot(),
+      };
+    }
+
+    this.state = applyMoveToState(this.state, legalMove, { recordHistory: true });
+    return {
+      ok: true,
+      move: legalMove,
+      state: this.getSnapshot(),
+      status: { ...this.state.status },
+    };
+  }
+
+  static positionHash(state) {
+    return positionHash(state);
+  }
+
+  static isInCheck(state, color) {
+    return isInCheck(state, color);
+  }
+
+  static evaluateStatus(state) {
+    return evaluateStatus(state);
+  }
+
+  static playMove(state, move, options = {}) {
+    return applyMoveToState(state, move, options);
+  }
+
+  static findLegalMove(state, input) {
+    const from = typeof input.from === "string" ? input.from.toLowerCase() : "";
+    const to = typeof input.to === "string" ? input.to.toLowerCase() : "";
+    const promotion = input.promotion ? input.promotion.toLowerCase() : null;
+
+    return ChessEngine.generateLegalMovesForState(state, state.turn).find(
+      (move) =>
+        move.from === from &&
+        move.to === to &&
+        (move.promotion || null) === (promotion || null),
+    );
+  }
+
+  static generateLegalMovesForState(state, color = state.turn) {
+    const legalMoves = [];
+
+    for (let y = 0; y < 8; y += 1) {
+      for (let x = 0; x < 8; x += 1) {
+        const piece = pieceAt(state.board, x, y);
+        if (!piece || piece.color !== color) {
+          continue;
+        }
+
+        const pseudoMoves = generatePseudoMoves(state, x, y);
+        for (const move of pseudoMoves) {
+          const nextState = applyMoveToState(state, move, {
+            recordHistory: false,
+            computeStatus: false,
+            updatePositionCounts: false,
+          });
+          if (!isInCheck(nextState, color)) {
+            legalMoves.push(move);
+          }
+        }
+      }
+    }
+
+    return legalMoves;
+  }
+}
+
+export const ChessRules = {
+  FILES,
+  colorLabel,
+  fromSquare,
+  toSquare,
+};