@connectorvol/chessops 0.16.0 → 2.0.0

package/src/attacks.ts

@@ -1,160 +0,0 @@
-/**
- * Compute attacks and rays.
- *
- * These are low-level functions that can be used to implement chess rules.
- *
- * Implementation notes: Sliding attacks are computed using
- * [Hyperbola Quintessence](https://www.chessprogramming.org/Hyperbola_Quintessence).
- * Magic Bitboards would deliver slightly faster lookups, but also require
- * initializing considerably larger attack tables. On the web, initialization
- * time is important, so the chosen method may strike a better balance.
- *
- * @packageDocumentation
- */
-
-import { SquareSet } from "./squareSet.js";
-import { BySquare, Color, Piece, Square } from "./types.js";
-import { squareFile, squareRank } from "./util.js";
-
-const computeRange = (square: Square, deltas: number[]): SquareSet => {
-  let range = SquareSet.empty();
-  for (const delta of deltas) {
-    const sq = square + delta;
-    if (0 <= sq && sq < 64 && Math.abs(squareFile(square) - squareFile(sq)) <= 2) {
-      range = range.with(sq);
-    }
-  }
-  return range;
-};
-
-const tabulate = <T>(f: (square: Square) => T): BySquare<T> => {
-  const table = [];
-  for (let square = 0; square < 64; square++) table[square] = f(square);
-  return table;
-};
-
-const KING_ATTACKS = tabulate((sq) => computeRange(sq, [-9, -8, -7, -1, 1, 7, 8, 9]));
-const KNIGHT_ATTACKS = tabulate((sq) => computeRange(sq, [-17, -15, -10, -6, 6, 10, 15, 17]));
-const PAWN_ATTACKS = {
-  white: tabulate((sq) => computeRange(sq, [7, 9])),
-  black: tabulate((sq) => computeRange(sq, [-7, -9])),
-};
-
-/**
- * Gets squares attacked or defended by a king on `square`.
- */
-export const kingAttacks = (square: Square): SquareSet => KING_ATTACKS[square];
-
-/**
- * Gets squares attacked or defended by a knight on `square`.
- */
-export const knightAttacks = (square: Square): SquareSet => KNIGHT_ATTACKS[square];
-
-/**
- * Gets squares attacked or defended by a pawn of the given `color`
- * on `square`.
- */
-export const pawnAttacks = (color: Color, square: Square): SquareSet => PAWN_ATTACKS[color][square];
-
-const FILE_RANGE = tabulate((sq) => SquareSet.fromFile(squareFile(sq)).without(sq));
-const RANK_RANGE = tabulate((sq) => SquareSet.fromRank(squareRank(sq)).without(sq));
-
-const DIAG_RANGE = tabulate((sq) => {
-  const diag = new SquareSet(0x0804_0201, 0x8040_2010);
-  const shift = 8 * (squareRank(sq) - squareFile(sq));
-  return (shift >= 0 ? diag.shl64(shift) : diag.shr64(-shift)).without(sq);
-});
-
-const ANTI_DIAG_RANGE = tabulate((sq) => {
-  const diag = new SquareSet(0x1020_4080, 0x0102_0408);
-  const shift = 8 * (squareRank(sq) + squareFile(sq) - 7);
-  return (shift >= 0 ? diag.shl64(shift) : diag.shr64(-shift)).without(sq);
-});
-
-const hyperbola = (bit: SquareSet, range: SquareSet, occupied: SquareSet): SquareSet => {
-  let forward = occupied.intersect(range);
-  let reverse = forward.bswap64(); // Assumes no more than 1 bit per rank
-  forward = forward.minus64(bit);
-  reverse = reverse.minus64(bit.bswap64());
-  return forward.xor(reverse.bswap64()).intersect(range);
-};
-
-const fileAttacks = (square: Square, occupied: SquareSet): SquareSet =>
-  hyperbola(SquareSet.fromSquare(square), FILE_RANGE[square], occupied);
-
-const rankAttacks = (square: Square, occupied: SquareSet): SquareSet => {
-  const range = RANK_RANGE[square];
-  let forward = occupied.intersect(range);
-  let reverse = forward.rbit64();
-  forward = forward.minus64(SquareSet.fromSquare(square));
-  reverse = reverse.minus64(SquareSet.fromSquare(63 - square));
-  return forward.xor(reverse.rbit64()).intersect(range);
-};
-
-/**
- * Gets squares attacked or defended by a bishop on `square`, given `occupied`
- * squares.
- */
-export const bishopAttacks = (square: Square, occupied: SquareSet): SquareSet => {
-  const bit = SquareSet.fromSquare(square);
-  return hyperbola(bit, DIAG_RANGE[square], occupied).xor(
-    hyperbola(bit, ANTI_DIAG_RANGE[square], occupied),
-  );
-};
-
-/**
- * Gets squares attacked or defended by a rook on `square`, given `occupied`
- * squares.
- */
-export const rookAttacks = (square: Square, occupied: SquareSet): SquareSet =>
-  fileAttacks(square, occupied).xor(rankAttacks(square, occupied));
-
-/**
- * Gets squares attacked or defended by a queen on `square`, given `occupied`
- * squares.
- */
-export const queenAttacks = (square: Square, occupied: SquareSet): SquareSet =>
-  bishopAttacks(square, occupied).xor(rookAttacks(square, occupied));
-
-/**
- * Gets squares attacked or defended by a `piece` on `square`, given
- * `occupied` squares.
- */
-export const attacks = (piece: Piece, square: Square, occupied: SquareSet): SquareSet => {
-  switch (piece.role) {
-    case "pawn":
-      return pawnAttacks(piece.color, square);
-    case "knight":
-      return knightAttacks(square);
-    case "bishop":
-      return bishopAttacks(square, occupied);
-    case "rook":
-      return rookAttacks(square, occupied);
-    case "queen":
-      return queenAttacks(square, occupied);
-    case "king":
-      return kingAttacks(square);
-  }
-};
-
-/**
- * Gets all squares of the rank, file or diagonal with the two squares
- * `a` and `b`, or an empty set if they are not aligned.
- */
-export const ray = (a: Square, b: Square): SquareSet => {
-  const other = SquareSet.fromSquare(b);
-  if (RANK_RANGE[a].intersects(other)) return RANK_RANGE[a].with(a);
-  if (ANTI_DIAG_RANGE[a].intersects(other)) return ANTI_DIAG_RANGE[a].with(a);
-  if (DIAG_RANGE[a].intersects(other)) return DIAG_RANGE[a].with(a);
-  if (FILE_RANGE[a].intersects(other)) return FILE_RANGE[a].with(a);
-  return SquareSet.empty();
-};
-
-/**
- * Gets all squares between `a` and `b` (bounds not included), or an empty set
- * if they are not on the same rank, file or diagonal.
- */
-export const between = (a: Square, b: Square): SquareSet =>
-  ray(a, b)
-    .intersect(SquareSet.full().shl64(a).xor(SquareSet.full().shl64(b)))
-    .withoutFirst();

package/src/board.ts

@@ -1,168 +0,0 @@
-import { SquareSet } from "./squareSet.js";
-import { ByColor, ByRole, Color, COLORS, Piece, Role, ROLES, Square } from "./types.js";
-
-/**
- * Piece positions on a board.
- *
- * Properties are sets of squares, like `board.occupied` for all occupied
- * squares, `board[color]` for all pieces of that color, and `board[role]`
- * for all pieces of that role. When modifying the properties directly, take
- * care to keep them consistent.
- */
-export class Board implements Iterable<[Square, Piece]>, ByRole<SquareSet>, ByColor<SquareSet> {
-  /**
-   * All occupied squares.
-   */
-  occupied: SquareSet;
-  /**
-   * All squares occupied by pieces known to be promoted. This information is
-   * relevant in chess variants like Crazyhouse.
-   */
-  promoted: SquareSet;
-
-  white: SquareSet;
-  black: SquareSet;
-
-  pawn: SquareSet;
-  knight: SquareSet;
-  bishop: SquareSet;
-  rook: SquareSet;
-  queen: SquareSet;
-  king: SquareSet;
-
-  private constructor() {}
-
-  static default(): Board {
-    const board = new Board();
-    board.reset();
-    return board;
-  }
-
-  /**
-   * Resets all pieces to the default starting position for standard chess.
-   */
-  reset(): void {
-    this.occupied = new SquareSet(0xffff, 0xffff_0000);
-    this.promoted = SquareSet.empty();
-    this.white = new SquareSet(0xffff, 0);
-    this.black = new SquareSet(0, 0xffff_0000);
-    this.pawn = new SquareSet(0xff00, 0x00ff_0000);
-    this.knight = new SquareSet(0x42, 0x4200_0000);
-    this.bishop = new SquareSet(0x24, 0x2400_0000);
-    this.rook = new SquareSet(0x81, 0x8100_0000);
-    this.queen = new SquareSet(0x8, 0x0800_0000);
-    this.king = new SquareSet(0x10, 0x1000_0000);
-  }
-
-  static empty(): Board {
-    const board = new Board();
-    board.clear();
-    return board;
-  }
-
-  clear(): void {
-    this.occupied = SquareSet.empty();
-    this.promoted = SquareSet.empty();
-    for (const color of COLORS) this[color] = SquareSet.empty();
-    for (const role of ROLES) this[role] = SquareSet.empty();
-  }
-
-  clone(): Board {
-    const board = new Board();
-    board.occupied = this.occupied;
-    board.promoted = this.promoted;
-    for (const color of COLORS) board[color] = this[color];
-    for (const role of ROLES) board[role] = this[role];
-    return board;
-  }
-
-  getColor(square: Square): Color | undefined {
-    if (this.white.has(square)) return "white";
-    if (this.black.has(square)) return "black";
-    return;
-  }
-
-  getRole(square: Square): Role | undefined {
-    for (const role of ROLES) {
-      if (this[role].has(square)) return role;
-    }
-    return;
-  }
-
-  get(square: Square): Piece | undefined {
-    const color = this.getColor(square);
-    if (!color) return;
-    const role = this.getRole(square)!;
-    const promoted = this.promoted.has(square);
-    return { color, role, promoted };
-  }
-
-  /**
-   * Removes and returns the piece from the given `square`, if any.
-   */
-  take(square: Square): Piece | undefined {
-    const piece = this.get(square);
-    if (piece) {
-      this.occupied = this.occupied.without(square);
-      this[piece.color] = this[piece.color].without(square);
-      this[piece.role] = this[piece.role].without(square);
-      if (piece.promoted) this.promoted = this.promoted.without(square);
-    }
-    return piece;
-  }
-
-  /**
-   * Put `piece` onto `square`, potentially replacing an existing piece.
-   * Returns the existing piece, if any.
-   */
-  set(square: Square, piece: Piece): Piece | undefined {
-    const old = this.take(square);
-    this.occupied = this.occupied.with(square);
-    this[piece.color] = this[piece.color].with(square);
-    this[piece.role] = this[piece.role].with(square);
-    if (piece.promoted) this.promoted = this.promoted.with(square);
-    return old;
-  }
-
-  has(square: Square): boolean {
-    return this.occupied.has(square);
-  }
-
-  *[Symbol.iterator](): Iterator<[Square, Piece]> {
-    for (const square of this.occupied) {
-      yield [square, this.get(square)!];
-    }
-  }
-
-  pieces(color: Color, role: Role): SquareSet {
-    return this[color].intersect(this[role]);
-  }
-
-  rooksAndQueens(): SquareSet {
-    return this.rook.union(this.queen);
-  }
-
-  bishopsAndQueens(): SquareSet {
-    return this.bishop.union(this.queen);
-  }
-
-  steppers(): SquareSet {
-    return this.knight.union(this.pawn).union(this.king);
-  }
-
-  sliders(): SquareSet {
-    return this.bishop.union(this.rook).union(this.queen);
-  }
-
-  /**
-   * Finds the unique king of the given `color`, if any.
-   */
-  kingOf(color: Color): Square | undefined {
-    return this.pieces(color, "king").singleSquare();
-  }
-}
-
-export const boardEquals = (left: Board, right: Board): boolean =>
-  left.white.equals(right.white) &&
-  left.promoted.equals(right.promoted) &&
-  ROLES.every((role) => left[role].equals(right[role]));