@connectorvol/chessops 0.15.1

package/src/san.ts

@@ -0,0 +1,190 @@
+import {
+  attacks,
+  bishopAttacks,
+  kingAttacks,
+  knightAttacks,
+  queenAttacks,
+  rookAttacks,
+} from "./attacks.js";
+import { Position } from "./chess.js";
+import { SquareSet } from "./squareSet.js";
+import { CastlingSide, FILE_NAMES, isDrop, Move, RANK_NAMES, SquareName } from "./types.js";
+import {
+  charToRole,
+  defined,
+  makeSquare,
+  opposite,
+  parseSquare,
+  roleToChar,
+  squareFile,
+  squareRank,
+} from "./util.js";
+
+const makeSanWithoutSuffix = (pos: Position, move: Move): string => {
+  let san = "";
+  if (isDrop(move)) {
+    if (move.role !== "pawn") san = roleToChar(move.role).toUpperCase();
+    san += "@" + makeSquare(move.to);
+  } else {
+    const role = pos.board.getRole(move.from);
+    if (!role) return "--";
+    if (
+      role === "king" &&
+      (pos.board[pos.turn].has(move.to) || Math.abs(move.to - move.from) === 2)
+    ) {
+      san = move.to > move.from ? "O-O" : "O-O-O";
+    } else {
+      const capture =
+        pos.board.occupied.has(move.to) ||
+        (role === "pawn" && squareFile(move.from) !== squareFile(move.to));
+      if (role !== "pawn") {
+        san = roleToChar(role).toUpperCase();
+
+        // Disambiguation
+        let others;
+        if (role === "king") others = kingAttacks(move.to).intersect(pos.board.king);
+        else if (role === "queen")
+          others = queenAttacks(move.to, pos.board.occupied).intersect(pos.board.queen);
+        else if (role === "rook")
+          others = rookAttacks(move.to, pos.board.occupied).intersect(pos.board.rook);
+        else if (role === "bishop")
+          others = bishopAttacks(move.to, pos.board.occupied).intersect(pos.board.bishop);
+        else others = knightAttacks(move.to).intersect(pos.board.knight);
+        others = others.intersect(pos.board[pos.turn]).without(move.from);
+        if (others.nonEmpty()) {
+          const ctx = pos.ctx();
+          for (const from of others) {
+            if (!pos.dests(from, ctx).has(move.to)) others = others.without(from);
+          }
+          if (others.nonEmpty()) {
+            let row = false;
+            let column = others.intersects(SquareSet.fromRank(squareRank(move.from)));
+            if (others.intersects(SquareSet.fromFile(squareFile(move.from)))) row = true;
+            else column = true;
+            if (column) san += FILE_NAMES[squareFile(move.from)];
+            if (row) san += RANK_NAMES[squareRank(move.from)];
+          }
+        }
+      } else if (capture) san = FILE_NAMES[squareFile(move.from)];
+
+      if (capture) san += "x";
+      san += makeSquare(move.to);
+      if (move.promotion) san += "=" + roleToChar(move.promotion).toUpperCase();
+    }
+  }
+  return san;
+};
+
+export const makeSanAndPlay = (pos: Position, move: Move): string => {
+  const san = makeSanWithoutSuffix(pos, move);
+  pos.play(move);
+  if (pos.outcome()?.winner) return san + "#";
+  if (pos.isCheck()) return san + "+";
+  return san;
+};
+
+export const makeSanVariation = (pos: Position, variation: Move[]): string => {
+  pos = pos.clone();
+  const line = [];
+  for (let i = 0; i < variation.length; i++) {
+    if (i !== 0) line.push(" ");
+    if (pos.turn === "white") line.push(pos.fullmoves, ". ");
+    else if (i === 0) line.push(pos.fullmoves, "... ");
+    const san = makeSanWithoutSuffix(pos, variation[i]);
+    pos.play(variation[i]);
+    line.push(san);
+    if (san === "--") return line.join("");
+    if (i === variation.length - 1 && pos.outcome()?.winner) line.push("#");
+    else if (pos.isCheck()) line.push("+");
+  }
+  return line.join("");
+};
+
+export const makeSan = (pos: Position, move: Move): string => makeSanAndPlay(pos.clone(), move);
+
+export const parseSan = (pos: Position, san: string): Move | undefined => {
+  const ctx = pos.ctx();
+
+  // Normal move
+  const match = san.match(
+    /^([NBRQK])?([a-h])?([1-8])?[-x]?([a-h][1-8])(?:=?([nbrqkNBRQK]))?[+#]?$/,
+  ) as
+    | [
+        string,
+        "N" | "B" | "R" | "Q" | "K" | undefined,
+        string | undefined,
+        string | undefined,
+        SquareName,
+        "n" | "b" | "r" | "q" | "k" | "N" | "B" | "R" | "Q" | "K" | undefined,
+      ]
+    | null;
+  if (!match) {
+    // Castling
+    let castlingSide: CastlingSide | undefined;
+    if (san === "O-O" || san === "O-O+" || san === "O-O#") castlingSide = "h";
+    else if (san === "O-O-O" || san === "O-O-O+" || san === "O-O-O#") castlingSide = "a";
+    if (castlingSide) {
+      const rook = pos.castles.rook[pos.turn][castlingSide];
+      if (!defined(ctx.king) || !defined(rook) || !pos.dests(ctx.king, ctx).has(rook)) return;
+      return {
+        from: ctx.king,
+        to: rook,
+      };
+    }
+
+    // Drop
+    const match = san.match(/^([pnbrqkPNBRQK])?@([a-h][1-8])[+#]?$/) as
+      | [
+          string,
+          "p" | "n" | "b" | "r" | "q" | "k" | "P" | "N" | "B" | "R" | "Q" | "K" | undefined,
+          SquareName,
+        ]
+      | null;
+    if (!match) return;
+    const move = {
+      role: match[1] ? charToRole(match[1]) : "pawn",
+      to: parseSquare(match[2]),
+    };
+    return pos.isLegal(move, ctx) ? move : undefined;
+  }
+  const role = match[1] ? charToRole(match[1]) : "pawn";
+  const to = parseSquare(match[4]);
+
+  const promotion = match[5] ? charToRole(match[5]) : undefined;
+  if (!!promotion !== (role === "pawn" && SquareSet.backranks().has(to))) return;
+  if (promotion === "king" && pos.rules !== "antichess") return;
+
+  let candidates = pos.board.pieces(pos.turn, role);
+  if (role === "pawn" && !match[2])
+    candidates = candidates.intersect(SquareSet.fromFile(squareFile(to)));
+  else if (match[2])
+    candidates = candidates.intersect(
+      SquareSet.fromFile(match[2].charCodeAt(0) - "a".charCodeAt(0)),
+    );
+  if (match[3])
+    candidates = candidates.intersect(
+      SquareSet.fromRank(match[3].charCodeAt(0) - "1".charCodeAt(0)),
+    );
+
+  // Optimization: Reduce set of candidates
+  const pawnAdvance = role === "pawn" ? SquareSet.fromFile(squareFile(to)) : SquareSet.empty();
+  candidates = candidates.intersect(
+    pawnAdvance.union(attacks({ color: opposite(pos.turn), role }, to, pos.board.occupied)),
+  );
+
+  // Check uniqueness and legality
+  let from;
+  for (const candidate of candidates) {
+    if (pos.dests(candidate, ctx).has(to)) {
+      if (defined(from)) return; // Ambiguous
+      from = candidate;
+    }
+  }
+  if (!defined(from)) return; // Illegal
+
+  return {
+    from,
+    to,
+    promotion,
+  };
+};

package/src/setup.ts

@@ -0,0 +1,203 @@
+import { Board, boardEquals } from "./board.js";
+import { SquareSet } from "./squareSet.js";
+import { ByColor, ByRole, Color, Role, ROLES, Square } from "./types.js";
+
+export class MaterialSide implements ByRole<number> {
+  pawn: number;
+  knight: number;
+  bishop: number;
+  rook: number;
+  queen: number;
+  king: number;
+
+  private constructor() {}
+
+  static empty(): MaterialSide {
+    const m = new MaterialSide();
+    for (const role of ROLES) m[role] = 0;
+    return m;
+  }
+
+  static fromBoard(board: Board, color: Color): MaterialSide {
+    const m = new MaterialSide();
+    for (const role of ROLES) m[role] = board.pieces(color, role).size();
+    return m;
+  }
+
+  clone(): MaterialSide {
+    const m = new MaterialSide();
+    for (const role of ROLES) m[role] = this[role];
+    return m;
+  }
+
+  equals(other: MaterialSide): boolean {
+    return ROLES.every((role) => this[role] === other[role]);
+  }
+
+  add(other: MaterialSide): MaterialSide {
+    const m = new MaterialSide();
+    for (const role of ROLES) m[role] = this[role] + other[role];
+    return m;
+  }
+
+  subtract(other: MaterialSide): MaterialSide {
+    const m = new MaterialSide();
+    for (const role of ROLES) m[role] = this[role] - other[role];
+    return m;
+  }
+
+  nonEmpty(): boolean {
+    return ROLES.some((role) => this[role] > 0);
+  }
+
+  isEmpty(): boolean {
+    return !this.nonEmpty();
+  }
+
+  hasPawns(): boolean {
+    return this.pawn > 0;
+  }
+
+  hasNonPawns(): boolean {
+    return this.knight > 0 || this.bishop > 0 || this.rook > 0 || this.queen > 0 || this.king > 0;
+  }
+
+  size(): number {
+    return this.pawn + this.knight + this.bishop + this.rook + this.queen + this.king;
+  }
+}
+
+export class Material implements ByColor<MaterialSide> {
+  constructor(
+    public white: MaterialSide,
+    public black: MaterialSide,
+  ) {}
+
+  static empty(): Material {
+    return new Material(MaterialSide.empty(), MaterialSide.empty());
+  }
+
+  static fromBoard(board: Board): Material {
+    return new Material(
+      MaterialSide.fromBoard(board, "white"),
+      MaterialSide.fromBoard(board, "black"),
+    );
+  }
+
+  clone(): Material {
+    return new Material(this.white.clone(), this.black.clone());
+  }
+
+  equals(other: Material): boolean {
+    return this.white.equals(other.white) && this.black.equals(other.black);
+  }
+
+  add(other: Material): Material {
+    return new Material(this.white.add(other.white), this.black.add(other.black));
+  }
+
+  subtract(other: Material): Material {
+    return new Material(this.white.subtract(other.white), this.black.subtract(other.black));
+  }
+
+  count(role: Role): number {
+    return this.white[role] + this.black[role];
+  }
+
+  size(): number {
+    return this.white.size() + this.black.size();
+  }
+
+  isEmpty(): boolean {
+    return this.white.isEmpty() && this.black.isEmpty();
+  }
+
+  nonEmpty(): boolean {
+    return !this.isEmpty();
+  }
+
+  hasPawns(): boolean {
+    return this.white.hasPawns() || this.black.hasPawns();
+  }
+
+  hasNonPawns(): boolean {
+    return this.white.hasNonPawns() || this.black.hasNonPawns();
+  }
+}
+
+export class RemainingChecks implements ByColor<number> {
+  constructor(
+    public white: number,
+    public black: number,
+  ) {}
+
+  static default(): RemainingChecks {
+    return new RemainingChecks(3, 3);
+  }
+
+  clone(): RemainingChecks {
+    return new RemainingChecks(this.white, this.black);
+  }
+
+  equals(other: RemainingChecks): boolean {
+    return this.white === other.white && this.black === other.black;
+  }
+}
+
+/**
+ * A not necessarily legal chess or chess variant position.
+ */
+export interface Setup {
+  board: Board;
+  pockets: Material | undefined;
+  turn: Color;
+  castlingRights: SquareSet;
+  epSquare: Square | undefined;
+  remainingChecks: RemainingChecks | undefined;
+  halfmoves: number;
+  fullmoves: number;
+}
+
+export const defaultSetup = (): Setup => ({
+  board: Board.default(),
+  pockets: undefined,
+  turn: "white",
+  castlingRights: SquareSet.corners(),
+  epSquare: undefined,
+  remainingChecks: undefined,
+  halfmoves: 0,
+  fullmoves: 1,
+});
+
+export const emptySetup = (): Setup => ({
+  board: Board.empty(),
+  pockets: undefined,
+  turn: "white",
+  castlingRights: SquareSet.empty(),
+  epSquare: undefined,
+  remainingChecks: undefined,
+  halfmoves: 0,
+  fullmoves: 1,
+});
+
+export const setupClone = (setup: Setup): Setup => ({
+  board: setup.board.clone(),
+  pockets: setup.pockets?.clone(),
+  turn: setup.turn,
+  castlingRights: setup.castlingRights,
+  epSquare: setup.epSquare,
+  remainingChecks: setup.remainingChecks?.clone(),
+  halfmoves: setup.halfmoves,
+  fullmoves: setup.fullmoves,
+});
+
+export const setupEquals = (left: Setup, right: Setup): boolean =>
+  boardEquals(left.board, right.board) &&
+  ((right.pockets && left.pockets?.equals(right.pockets)) || (!left.pockets && !right.pockets)) &&
+  left.turn === right.turn &&
+  left.castlingRights.equals(right.castlingRights) &&
+  left.epSquare === right.epSquare &&
+  ((right.remainingChecks && left.remainingChecks?.equals(right.remainingChecks)) ||
+    (!left.remainingChecks && !right.remainingChecks)) &&
+  left.halfmoves === right.halfmoves &&
+  left.fullmoves === right.fullmoves;

package/src/squareSet.ts

@@ -0,0 +1,243 @@
+import { Color, Square } from "./types.js";
+
+const popcnt32 = (n: number): number => {
+  n = n - ((n >>> 1) & 0x5555_5555);
+  n = (n & 0x3333_3333) + ((n >>> 2) & 0x3333_3333);
+  return Math.imul((n + (n >>> 4)) & 0x0f0f_0f0f, 0x0101_0101) >> 24;
+};
+
+const bswap32 = (n: number): number => {
+  n = ((n >>> 8) & 0x00ff_00ff) | ((n & 0x00ff_00ff) << 8);
+  return ((n >>> 16) & 0xffff) | ((n & 0xffff) << 16);
+};
+
+const rbit32 = (n: number): number => {
+  n = ((n >>> 1) & 0x5555_5555) | ((n & 0x5555_5555) << 1);
+  n = ((n >>> 2) & 0x3333_3333) | ((n & 0x3333_3333) << 2);
+  n = ((n >>> 4) & 0x0f0f_0f0f) | ((n & 0x0f0f_0f0f) << 4);
+  return bswap32(n);
+};
+
+/**
+ * An immutable set of squares, implemented as a bitboard.
+ */
+export class SquareSet implements Iterable<Square> {
+  readonly lo: number;
+  readonly hi: number;
+
+  constructor(lo: number, hi: number) {
+    this.lo = lo | 0;
+    this.hi = hi | 0;
+  }
+
+  static fromSquare(square: Square): SquareSet {
+    return square >= 32 ? new SquareSet(0, 1 << (square - 32)) : new SquareSet(1 << square, 0);
+  }
+
+  static fromRank(rank: number): SquareSet {
+    return new SquareSet(0xff, 0).shl64(8 * rank);
+  }
+
+  static fromFile(file: number): SquareSet {
+    return new SquareSet(0x0101_0101 << file, 0x0101_0101 << file);
+  }
+
+  static empty(): SquareSet {
+    return new SquareSet(0, 0);
+  }
+
+  static full(): SquareSet {
+    return new SquareSet(0xffff_ffff, 0xffff_ffff);
+  }
+
+  static corners(): SquareSet {
+    return new SquareSet(0x81, 0x8100_0000);
+  }
+
+  static center(): SquareSet {
+    return new SquareSet(0x1800_0000, 0x18);
+  }
+
+  static backranks(): SquareSet {
+    return new SquareSet(0xff, 0xff00_0000);
+  }
+
+  static backrank(color: Color): SquareSet {
+    return color === "white" ? new SquareSet(0xff, 0) : new SquareSet(0, 0xff00_0000);
+  }
+
+  static lightSquares(): SquareSet {
+    return new SquareSet(0x55aa_55aa, 0x55aa_55aa);
+  }
+
+  static darkSquares(): SquareSet {
+    return new SquareSet(0xaa55_aa55, 0xaa55_aa55);
+  }
+
+  complement(): SquareSet {
+    return new SquareSet(~this.lo, ~this.hi);
+  }
+
+  xor(other: SquareSet): SquareSet {
+    return new SquareSet(this.lo ^ other.lo, this.hi ^ other.hi);
+  }
+
+  union(other: SquareSet): SquareSet {
+    return new SquareSet(this.lo | other.lo, this.hi | other.hi);
+  }
+
+  intersect(other: SquareSet): SquareSet {
+    return new SquareSet(this.lo & other.lo, this.hi & other.hi);
+  }
+
+  diff(other: SquareSet): SquareSet {
+    return new SquareSet(this.lo & ~other.lo, this.hi & ~other.hi);
+  }
+
+  intersects(other: SquareSet): boolean {
+    return this.intersect(other).nonEmpty();
+  }
+
+  isDisjoint(other: SquareSet): boolean {
+    return this.intersect(other).isEmpty();
+  }
+
+  supersetOf(other: SquareSet): boolean {
+    return other.diff(this).isEmpty();
+  }
+
+  subsetOf(other: SquareSet): boolean {
+    return this.diff(other).isEmpty();
+  }
+
+  shr64(shift: number): SquareSet {
+    if (shift >= 64) return SquareSet.empty();
+    if (shift >= 32) return new SquareSet(this.hi >>> (shift - 32), 0);
+    if (shift > 0)
+      return new SquareSet((this.lo >>> shift) ^ (this.hi << (32 - shift)), this.hi >>> shift);
+    return this;
+  }
+
+  shl64(shift: number): SquareSet {
+    if (shift >= 64) return SquareSet.empty();
+    if (shift >= 32) return new SquareSet(0, this.lo << (shift - 32));
+    if (shift > 0)
+      return new SquareSet(this.lo << shift, (this.hi << shift) ^ (this.lo >>> (32 - shift)));
+    return this;
+  }
+
+  bswap64(): SquareSet {
+    return new SquareSet(bswap32(this.hi), bswap32(this.lo));
+  }
+
+  rbit64(): SquareSet {
+    return new SquareSet(rbit32(this.hi), rbit32(this.lo));
+  }
+
+  minus64(other: SquareSet): SquareSet {
+    const lo = this.lo - other.lo;
+    const c = ((lo & other.lo & 1) + (other.lo >>> 1) + (lo >>> 1)) >>> 31;
+    return new SquareSet(lo, this.hi - (other.hi + c));
+  }
+
+  equals(other: SquareSet): boolean {
+    return this.lo === other.lo && this.hi === other.hi;
+  }
+
+  size(): number {
+    return popcnt32(this.lo) + popcnt32(this.hi);
+  }
+
+  isEmpty(): boolean {
+    return this.lo === 0 && this.hi === 0;
+  }
+
+  nonEmpty(): boolean {
+    return this.lo !== 0 || this.hi !== 0;
+  }
+
+  has(square: Square): boolean {
+    return (square >= 32 ? this.hi & (1 << (square - 32)) : this.lo & (1 << square)) !== 0;
+  }
+
+  set(square: Square, on: boolean): SquareSet {
+    return on ? this.with(square) : this.without(square);
+  }
+
+  with(square: Square): SquareSet {
+    return square >= 32
+      ? new SquareSet(this.lo, this.hi | (1 << (square - 32)))
+      : new SquareSet(this.lo | (1 << square), this.hi);
+  }
+
+  without(square: Square): SquareSet {
+    return square >= 32
+      ? new SquareSet(this.lo, this.hi & ~(1 << (square - 32)))
+      : new SquareSet(this.lo & ~(1 << square), this.hi);
+  }
+
+  toggle(square: Square): SquareSet {
+    return square >= 32
+      ? new SquareSet(this.lo, this.hi ^ (1 << (square - 32)))
+      : new SquareSet(this.lo ^ (1 << square), this.hi);
+  }
+
+  last(): Square | undefined {
+    if (this.hi !== 0) return 63 - Math.clz32(this.hi);
+    if (this.lo !== 0) return 31 - Math.clz32(this.lo);
+    return;
+  }
+
+  first(): Square | undefined {
+    if (this.lo !== 0) return 31 - Math.clz32(this.lo & -this.lo);
+    if (this.hi !== 0) return 63 - Math.clz32(this.hi & -this.hi);
+    return;
+  }
+
+  withoutFirst(): SquareSet {
+    if (this.lo !== 0) return new SquareSet(this.lo & (this.lo - 1), this.hi);
+    return new SquareSet(0, this.hi & (this.hi - 1));
+  }
+
+  moreThanOne(): boolean {
+    return (
+      (this.hi !== 0 && this.lo !== 0) ||
+      (this.lo & (this.lo - 1)) !== 0 ||
+      (this.hi & (this.hi - 1)) !== 0
+    );
+  }
+
+  singleSquare(): Square | undefined {
+    return this.moreThanOne() ? undefined : this.last();
+  }
+
+  *[Symbol.iterator](): Iterator<Square> {
+    let lo = this.lo;
+    let hi = this.hi;
+    while (lo !== 0) {
+      const idx = 31 - Math.clz32(lo & -lo);
+      lo ^= 1 << idx;
+      yield idx;
+    }
+    while (hi !== 0) {
+      const idx = 31 - Math.clz32(hi & -hi);
+      hi ^= 1 << idx;
+      yield 32 + idx;
+    }
+  }
+
+  *reversed(): Iterable<Square> {
+    let lo = this.lo;
+    let hi = this.hi;
+    while (hi !== 0) {
+      const idx = 31 - Math.clz32(hi);
+      hi ^= 1 << idx;
+      yield 32 + idx;
+    }
+    while (lo !== 0) {
+      const idx = 31 - Math.clz32(lo);
+      lo ^= 1 << idx;
+      yield idx;
+    }
+  }
+}

package/src/transform.ts

@@ -0,0 +1,49 @@
+import { Board } from "./board.js";
+import { Setup } from "./setup.js";
+import { SquareSet } from "./squareSet.js";
+import { COLORS, ROLES } from "./types.js";
+import { defined } from "./util.js";
+
+export const flipVertical = (s: SquareSet): SquareSet => s.bswap64();
+
+export const flipHorizontal = (s: SquareSet): SquareSet => {
+  const k1 = new SquareSet(0x55555555, 0x55555555);
+  const k2 = new SquareSet(0x33333333, 0x33333333);
+  const k4 = new SquareSet(0x0f0f0f0f, 0x0f0f0f0f);
+  s = s.shr64(1).intersect(k1).union(s.intersect(k1).shl64(1));
+  s = s.shr64(2).intersect(k2).union(s.intersect(k2).shl64(2));
+  s = s.shr64(4).intersect(k4).union(s.intersect(k4).shl64(4));
+  return s;
+};
+
+export const flipDiagonal = (s: SquareSet): SquareSet => {
+  let t = s.xor(s.shl64(28)).intersect(new SquareSet(0, 0x0f0f0f0f));
+  s = s.xor(t.xor(t.shr64(28)));
+  t = s.xor(s.shl64(14)).intersect(new SquareSet(0x33330000, 0x33330000));
+  s = s.xor(t.xor(t.shr64(14)));
+  t = s.xor(s.shl64(7)).intersect(new SquareSet(0x55005500, 0x55005500));
+  s = s.xor(t.xor(t.shr64(7)));
+  return s;
+};
+
+export const rotate180 = (s: SquareSet): SquareSet => s.rbit64();
+
+export const transformBoard = (board: Board, f: (s: SquareSet) => SquareSet): Board => {
+  const b = Board.empty();
+  b.occupied = f(board.occupied);
+  b.promoted = f(board.promoted);
+  for (const color of COLORS) b[color] = f(board[color]);
+  for (const role of ROLES) b[role] = f(board[role]);
+  return b;
+};
+
+export const transformSetup = (setup: Setup, f: (s: SquareSet) => SquareSet): Setup => ({
+  board: transformBoard(setup.board, f),
+  pockets: setup.pockets?.clone(),
+  turn: setup.turn,
+  castlingRights: f(setup.castlingRights),
+  epSquare: defined(setup.epSquare) ? f(SquareSet.fromSquare(setup.epSquare)).first() : undefined,
+  remainingChecks: setup.remainingChecks?.clone(),
+  halfmoves: setup.halfmoves,
+  fullmoves: setup.fullmoves,
+});