mbk/elo-worldle
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
elo-worldle/chess.js

1790 lines
64 KiB
JavaScript
Raw Normal View History

i am a git main
2023-03-26 23:33:41 -04:00
/**
* @license
* Copyright (c) 2023, Jeff Hlywa (jhlywa@gmail.com)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
export const WHITE = "w";
export const BLACK = "b";
export const PAWN = "p";
export const KNIGHT = "n";
export const BISHOP = "b";
export const ROOK = "r";
export const QUEEN = "q";
export const KING = "k";
export const PIECE_SYMBOLS = ["p", "n", "b", "r", "q", "k"];
export const DEFAULT_POSITION = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
const EMPTY = -1;
const FLAGS = {
NORMAL: "n",
CAPTURE: "c",
BIG_PAWN: "b",
EP_CAPTURE: "e",
PROMOTION: "p",
KSIDE_CASTLE: "k",
QSIDE_CASTLE: "q",
};
// prettier-ignore
export const SQUARES = [
'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8',
'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7',
'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6',
'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5',
'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4',
'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3',
'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2',
'a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1'
];
const BITS = {
NORMAL: 1,
CAPTURE: 2,
BIG_PAWN: 4,
EP_CAPTURE: 8,
PROMOTION: 16,
KSIDE_CASTLE: 32,
QSIDE_CASTLE: 64,
};
/*
* NOTES ABOUT 0x88 MOVE GENERATION ALGORITHM
* ----------------------------------------------------------------------------
* From https://github.com/jhlywa/chess.js/issues/230
*
* A lot of people are confused when they first see the internal representation
* of chess.js. It uses the 0x88 Move Generation Algorithm which internally
* stores the board as an 8x16 array. This is purely for efficiency but has a
* couple of interesting benefits:
*
* 1. 0x88 offers a very inexpensive "off the board" check. Bitwise AND (&) any
* square with 0x88, if the result is non-zero then the square is off the
* board. For example, assuming a knight square A8 (0 in 0x88 notation),
* there are 8 possible directions in which the knight can move. These
* directions are relative to the 8x16 board and are stored in the
* PIECE_OFFSETS map. One possible move is A8 - 18 (up one square, and two
* squares to the left - which is off the board). 0 - 18 = -18 & 0x88 = 0x88
* (because of two-complement representation of -18). The non-zero result
* means the square is off the board and the move is illegal. Take the
* opposite move (from A8 to C7), 0 + 18 = 18 & 0x88 = 0. A result of zero
* means the square is on the board.
*
* 2. The relative distance (or difference) between two squares on a 8x16 board
* is unique and can be used to inexpensively determine if a piece on a
* square can attack any other arbitrary square. For example, let's see if a
* pawn on E7 can attack E2. The difference between E7 (20) - E2 (100) is
* -80. We add 119 to make the ATTACKS array index non-negative (because the
* worst case difference is A8 - H1 = -119). The ATTACKS array contains a
* bitmask of pieces that can attack from that distance and direction.
* ATTACKS[-80 + 119=39] gives us 24 or 0b11000 in binary. Look at the
* PIECE_MASKS map to determine the mask for a given piece type. In our pawn
* example, we would check to see if 24 & 0x1 is non-zero, which it is
* not. So, naturally, a pawn on E7 can't attack a piece on E2. However, a
* rook can since 24 & 0x8 is non-zero. The only thing left to check is that
* there are no blocking pieces between E7 and E2. That's where the RAYS
* array comes in. It provides an offset (in this case 16) to add to E7 (20)
* to check for blocking pieces. E7 (20) + 16 = E6 (36) + 16 = E5 (52) etc.
*/
// prettier-ignore
// eslint-disable-next-line
export const Ox88 = {
a8: 0, b8: 1, c8: 2, d8: 3, e8: 4, f8: 5, g8: 6, h8: 7,
a7: 16, b7: 17, c7: 18, d7: 19, e7: 20, f7: 21, g7: 22, h7: 23,
a6: 32, b6: 33, c6: 34, d6: 35, e6: 36, f6: 37, g6: 38, h6: 39,
a5: 48, b5: 49, c5: 50, d5: 51, e5: 52, f5: 53, g5: 54, h5: 55,
a4: 64, b4: 65, c4: 66, d4: 67, e4: 68, f4: 69, g4: 70, h4: 71,
a3: 80, b3: 81, c3: 82, d3: 83, e3: 84, f3: 85, g3: 86, h3: 87,
a2: 96, b2: 97, c2: 98, d2: 99, e2: 100, f2: 101, g2: 102, h2: 103,
a1: 112, b1: 113, c1: 114, d1: 115, e1: 116, f1: 117, g1: 118, h1: 119
};
const PAWN_OFFSETS = {
b: [16, 32, 17, 15],
w: [-16, -32, -17, -15],
};
const PIECE_OFFSETS = {
n: [-18, -33, -31, -14, 18, 33, 31, 14],
b: [-17, -15, 17, 15],
r: [-16, 1, 16, -1],
q: [-17, -16, -15, 1, 17, 16, 15, -1],
k: [-17, -16, -15, 1, 17, 16, 15, -1],
};
// prettier-ignore
const ATTACKS = [
20, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 20, 0,
0, 20, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 20, 0, 0,
0, 0, 20, 0, 0, 0, 0, 24, 0, 0, 0, 0, 20, 0, 0, 0,
0, 0, 0, 20, 0, 0, 0, 24, 0, 0, 0, 20, 0, 0, 0, 0,
0, 0, 0, 0, 20, 0, 0, 24, 0, 0, 20, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 20, 2, 24, 2, 20, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 2, 53, 56, 53, 2, 0, 0, 0, 0, 0, 0,
24, 24, 24, 24, 24, 24, 56, 0, 56, 24, 24, 24, 24, 24, 24, 0,
0, 0, 0, 0, 0, 2, 53, 56, 53, 2, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 20, 2, 24, 2, 20, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 20, 0, 0, 24, 0, 0, 20, 0, 0, 0, 0, 0,
0, 0, 0, 20, 0, 0, 0, 24, 0, 0, 0, 20, 0, 0, 0, 0,
0, 0, 20, 0, 0, 0, 0, 24, 0, 0, 0, 0, 20, 0, 0, 0,
0, 20, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 20, 0, 0,
20, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 20
];
// prettier-ignore
const RAYS = [
17, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 15, 0,
0, 17, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 15, 0, 0,
0, 0, 17, 0, 0, 0, 0, 16, 0, 0, 0, 0, 15, 0, 0, 0,
0, 0, 0, 17, 0, 0, 0, 16, 0, 0, 0, 15, 0, 0, 0, 0,
0, 0, 0, 0, 17, 0, 0, 16, 0, 0, 15, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 17, 0, 16, 0, 15, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 17, 16, 15, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 0, -1, -1, -1, -1, -1, -1, -1, 0,
0, 0, 0, 0, 0, 0, -15, -16, -17, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, -15, 0, -16, 0, -17, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, -15, 0, 0, -16, 0, 0, -17, 0, 0, 0, 0, 0,
0, 0, 0, -15, 0, 0, 0, -16, 0, 0, 0, -17, 0, 0, 0, 0,
0, 0, -15, 0, 0, 0, 0, -16, 0, 0, 0, 0, -17, 0, 0, 0,
0, -15, 0, 0, 0, 0, 0, -16, 0, 0, 0, 0, 0, -17, 0, 0,
-15, 0, 0, 0, 0, 0, 0, -16, 0, 0, 0, 0, 0, 0, -17
];
const PIECE_MASKS = { p: 0x1, n: 0x2, b: 0x4, r: 0x8, q: 0x10, k: 0x20 };
const SYMBOLS = "pnbrqkPNBRQK";
const PROMOTIONS = [KNIGHT, BISHOP, ROOK, QUEEN];
const RANK_1 = 7;
const RANK_2 = 6;
/*
* const RANK_3 = 5
* const RANK_4 = 4
* const RANK_5 = 3
* const RANK_6 = 2
*/
const RANK_7 = 1;
const RANK_8 = 0;
const ROOKS = {
w: [
{ square: Ox88.a1, flag: BITS.QSIDE_CASTLE },
{ square: Ox88.h1, flag: BITS.KSIDE_CASTLE },
],
b: [
{ square: Ox88.a8, flag: BITS.QSIDE_CASTLE },
{ square: Ox88.h8, flag: BITS.KSIDE_CASTLE },
],
};
const SECOND_RANK = { b: RANK_7, w: RANK_2 };
const TERMINATION_MARKERS = ["1-0", "0-1", "1/2-1/2", "*"];
// Extracts the zero-based rank of an 0x88 square.
export function rank(square) {
return square >> 4;
}
// Extracts the zero-based file of an 0x88 square.
export function file(square) {
return square & 0xf;
}
function isDigit(c) {
return "0123456789".indexOf(c) !== -1;
}
// Converts a 0x88 square to algebraic notation.
function algebraic(square) {
const f = file(square);
const r = rank(square);
return ("abcdefgh".substring(f, f + 1) +
"87654321".substring(r, r + 1));
}
function swapColor(color) {
return color === WHITE ? BLACK : WHITE;
}
export function validateFen(fen) {
// 1st criterion: 6 space-seperated fields?
const tokens = fen.split(/\s+/);
if (tokens.length !== 6) {
return {
ok: false,
error: "Invalid FEN: must contain six space-delimited fields",
};
}
// 2nd criterion: move number field is a integer value > 0?
const moveNumber = parseInt(tokens[5], 10);
if (isNaN(moveNumber) || moveNumber <= 0) {
return {
ok: false,
error: "Invalid FEN: move number must be a positive integer",
};
}
// 3rd criterion: half move counter is an integer >= 0?
const halfMoves = parseInt(tokens[4], 10);
if (isNaN(halfMoves) || halfMoves < 0) {
return {
ok: false,
error: "Invalid FEN: half move counter number must be a non-negative integer",
};
}
// 4th criterion: 4th field is a valid e.p.-string?
if (!/^(-|[abcdefgh][36])$/.test(tokens[3])) {
return {
ok: false,
error: "Invalid FEN: en-passant square is invalid",
};
}
// 5th criterion: 3th field is a valid castle-string?
if (/[^kKqQ-]/.test(tokens[2])) {
return {
ok: false,
error: "Invalid FEN: castling availability is invalid",
};
}
// 6th criterion: 2nd field is "w" (white) or "b" (black)?
if (!/^(w|b)$/.test(tokens[1])) {
return { ok: false, error: "Invalid FEN: side-to-move is invalid" };
}
// 7th criterion: 1st field contains 8 rows?
const rows = tokens[0].split("/");
if (rows.length !== 8) {
return {
ok: false,
error: "Invalid FEN: piece data does not contain 8 '/'-delimited rows",
};
}
// 8th criterion: every row is valid?
for (let i = 0; i < rows.length; i++) {
// check for right sum of fields AND not two numbers in succession
let sumFields = 0;
let previousWasNumber = false;
for (let k = 0; k < rows[i].length; k++) {
if (isDigit(rows[i][k])) {
if (previousWasNumber) {
return {
ok: false,
error: "Invalid FEN: piece data is invalid (consecutive number)",
};
}
sumFields += parseInt(rows[i][k], 10);
previousWasNumber = true;
}
else {
if (!/^[prnbqkPRNBQK]$/.test(rows[i][k])) {
return {
ok: false,
error: "Invalid FEN: piece data is invalid (invalid piece)",
};
}
sumFields += 1;
previousWasNumber = false;
}
}
if (sumFields !== 8) {
return {
ok: false,
error: "Invalid FEN: piece data is invalid (too many squares in rank)",
};
}
}
if ((tokens[3][1] == "3" && tokens[1] == "w") ||
(tokens[3][1] == "6" && tokens[1] == "b")) {
return { ok: false, error: "Invalid FEN: illegal en-passant square" };
}
const kings = [
{ color: "white", regex: /K/g },
{ color: "black", regex: /k/g },
];
for (const { color, regex } of kings) {
if (!regex.test(tokens[0])) {
return { ok: false, error: `Invalid FEN: missing ${color} king` };
}
if ((tokens[0].match(regex) || []).length > 1) {
return { ok: false, error: `Invalid FEN: too many ${color} kings` };
}
}
return { ok: true };
}
// this function is used to uniquely identify ambiguous moves
function getDisambiguator(move, moves) {
const from = move.from;
const to = move.to;
const piece = move.piece;
let ambiguities = 0;
let sameRank = 0;
let sameFile = 0;
for (let i = 0, len = moves.length; i < len; i++) {
const ambigFrom = moves[i].from;
const ambigTo = moves[i].to;
const ambigPiece = moves[i].piece;
/*
* if a move of the same piece type ends on the same to square, we'll need
* to add a disambiguator to the algebraic notation
*/
if (piece === ambigPiece && from !== ambigFrom && to === ambigTo) {
ambiguities++;
if (rank(from) === rank(ambigFrom)) {
sameRank++;
}
if (file(from) === file(ambigFrom)) {
sameFile++;
}
}
}
if (ambiguities > 0) {
if (sameRank > 0 && sameFile > 0) {
/*
* if there exists a similar moving piece on the same rank and file as
* the move in question, use the square as the disambiguator
*/
return algebraic(from);
}
else if (sameFile > 0) {
/*
* if the moving piece rests on the same file, use the rank symbol as the
* disambiguator
*/
return algebraic(from).charAt(1);
}
else {
// else use the file symbol
return algebraic(from).charAt(0);
}
}
return "";
}
function addMove(moves, color, from, to, piece, captured = undefined, flags = BITS.NORMAL) {
const r = rank(to);
if (piece === PAWN && (r === RANK_1 || r === RANK_8)) {
for (let i = 0; i < PROMOTIONS.length; i++) {
const promotion = PROMOTIONS[i];
moves.push({
color,
from,
to,
piece,
captured,
promotion,
flags: flags | BITS.PROMOTION,
});
}
}
else {
moves.push({
color,
from,
to,
piece,
captured,
flags,
});
}
}
function inferPieceType(san) {
let pieceType = san.charAt(0);
if (pieceType >= "a" && pieceType <= "h") {
const matches = san.match(/[a-h]\d.*[a-h]\d/);
if (matches) {
return undefined;
}
return PAWN;
}
pieceType = pieceType.toLowerCase();
if (pieceType === "o") {
return KING;
}
return pieceType;
}
// parses all of the decorators out of a SAN string
function strippedSan(move) {
return move.replace(/=/, "").replace(/[+#]?[?!]*$/, "");
}
export class Chess {
constructor(fen = DEFAULT_POSITION) {
this._board = new Array(128);
this._turn = WHITE;
this._header = {};
this._kings = { w: EMPTY, b: EMPTY };
this._epSquare = -1;
this._halfMoves = 0;
this._moveNumber = 0;
this._history = [];
this._comments = {};
this._castling = { w: 0, b: 0 };
this.load(fen);
}
clear(keepHeaders = false) {
this._board = new Array(128);
this._kings = { w: EMPTY, b: EMPTY };
this._turn = WHITE;
this._castling = { w: 0, b: 0 };
this._epSquare = EMPTY;
this._halfMoves = 0;
this._moveNumber = 1;
this._history = [];
this._comments = {};
this._header = keepHeaders ? this._header : {};
this._updateSetup(this.fen());
}
load(fen, keepHeaders = false) {
let tokens = fen.split(/\s+/);
// append commonly omitted fen tokens
if (tokens.length >= 2 && tokens.length < 6) {
const adjustments = ["-", "-", "0", "1"];
fen = tokens
.concat(adjustments.slice(-(6 - tokens.length)))
.join(" ");
}
tokens = fen.split(/\s+/);
const { ok, error } = validateFen(fen);
if (!ok) {
throw new Error(error);
}
const position = tokens[0];
let square = 0;
this.clear(keepHeaders);
for (let i = 0; i < position.length; i++) {
const piece = position.charAt(i);
if (piece === "/") {
square += 8;
}
else if (isDigit(piece)) {
square += parseInt(piece, 10);
}
else {
const color = piece < "a" ? WHITE : BLACK;
this.put({ type: piece.toLowerCase(), color }, algebraic(square));
square++;
}
}
this._turn = tokens[1];
if (tokens[2].indexOf("K") > -1) {
this._castling.w |= BITS.KSIDE_CASTLE;
}
if (tokens[2].indexOf("Q") > -1) {
this._castling.w |= BITS.QSIDE_CASTLE;
}
if (tokens[2].indexOf("k") > -1) {
this._castling.b |= BITS.KSIDE_CASTLE;
}
if (tokens[2].indexOf("q") > -1) {
this._castling.b |= BITS.QSIDE_CASTLE;
}
this._epSquare = tokens[3] === "-" ? EMPTY : Ox88[tokens[3]];
this._halfMoves = parseInt(tokens[4], 10);
this._moveNumber = parseInt(tokens[5], 10);
this._updateSetup(this.fen());
}
fen() {
var _a, _b;
let empty = 0;
let fen = "";
for (let i = Ox88.a8; i <= Ox88.h1; i++) {
if (this._board[i]) {
if (empty > 0) {
fen += empty;
empty = 0;
}
const { color, type: piece } = this._board[i];
fen +=
color === WHITE ? piece.toUpperCase() : piece.toLowerCase();
}
else {
empty++;
}
if ((i + 1) & 0x88) {
if (empty > 0) {
fen += empty;
}
if (i !== Ox88.h1) {
fen += "/";
}
empty = 0;
i += 8;
}
}
let castling = "";
if (this._castling[WHITE] & BITS.KSIDE_CASTLE) {
castling += "K";
}
if (this._castling[WHITE] & BITS.QSIDE_CASTLE) {
castling += "Q";
}
if (this._castling[BLACK] & BITS.KSIDE_CASTLE) {
castling += "k";
}
if (this._castling[BLACK] & BITS.QSIDE_CASTLE) {
castling += "q";
}
// do we have an empty castling flag?
castling = castling || "-";
let epSquare = "-";
/*
* only print the ep square if en passant is a valid move (pawn is present
* and ep capture is not pinned)
*/
if (this._epSquare !== EMPTY) {
const bigPawnSquare = this._epSquare + (this._turn === WHITE ? 16 : -16);
const squares = [bigPawnSquare + 1, bigPawnSquare - 1];
for (const square of squares) {
// is the square off the board?
if (square & 0x88) {
continue;
}
const color = this._turn;
// is there a pawn that can capture the epSquare?
if (((_a = this._board[square]) === null || _a === void 0 ? void 0 : _a.color) === color &&
((_b = this._board[square]) === null || _b === void 0 ? void 0 : _b.type) === PAWN) {
// if the pawn makes an ep capture, does it leave it's king in check?
this._makeMove({
color,
from: square,
to: this._epSquare,
piece: PAWN,
captured: PAWN,
flags: BITS.EP_CAPTURE,
});
const isLegal = !this._isKingAttacked(color);
this._undoMove();
// if ep is legal, break and set the ep square in the FEN output
if (isLegal) {
epSquare = algebraic(this._epSquare);
break;
}
}
}
}
return [
fen,
this._turn,
castling,
epSquare,
this._halfMoves,
this._moveNumber,
].join(" ");
}
/*
* Called when the initial board setup is changed with put() or remove().
* modifies the SetUp and FEN properties of the header object. If the FEN
* is equal to the default position, the SetUp and FEN are deleted the setup
* is only updated if history.length is zero, ie moves haven't been made.
*/
_updateSetup(fen) {
if (this._history.length > 0)
return;
if (fen !== DEFAULT_POSITION) {
this._header["SetUp"] = "1";
this._header["FEN"] = fen;
}
else {
delete this._header["SetUp"];
delete this._header["FEN"];
}
}
reset() {
this.load(DEFAULT_POSITION);
}
get(square) {
var _a;
return (_a = this._board[Ox88[square]]) !== null && _a !== void 0 ? _a : false;
}
put({ type, color }, square) {
// check for piece
if (SYMBOLS.indexOf(type.toLowerCase()) === -1) {
return false;
}
// check for valid square
if (!(square in Ox88)) {
return false;
}
const sq = Ox88[square];
// don't let the user place more than one king
if (type == KING &&
!(this._kings[color] == EMPTY || this._kings[color] == sq)) {
return false;
}
this._board[sq] = { type: type, color: color };
if (type === KING) {
this._kings[color] = sq;
}
this._updateSetup(this.fen());
return true;
}
remove(square) {
const piece = this.get(square);
delete this._board[Ox88[square]];
if (piece && piece.type === KING) {
this._kings[piece.color] = EMPTY;
}
this._updateSetup(this.fen());
return piece;
}
_attacked(color, square) {
for (let i = Ox88.a8; i <= Ox88.h1; i++) {
// did we run off the end of the board
if (i & 0x88) {
i += 7;
continue;
}
// if empty square or wrong color
if (this._board[i] === undefined ||
this._board[i].color !== color) {
continue;
}
const piece = this._board[i];
const difference = i - square;
// skip - to/from square are the same
if (difference === 0) {
continue;
}
const index = difference + 119;
if (ATTACKS[index] & PIECE_MASKS[piece.type]) {
if (piece.type === PAWN) {
if (difference > 0) {
if (piece.color === WHITE)
return true;
}
else {
if (piece.color === BLACK)
return true;
}
continue;
}
// if the piece is a knight or a king
if (piece.type === "n" || piece.type === "k")
return true;
const offset = RAYS[index];
let j = i + offset;
let blocked = false;
while (j !== square) {
if (this._board[j] != null) {
blocked = true;
break;
}
j += offset;
}
if (!blocked)
return true;
}
}
return false;
}
_isKingAttacked(color) {
return this._attacked(swapColor(color), this._kings[color]);
}
isAttacked(square, attackedBy) {
return this._attacked(attackedBy, Ox88[square]);
}
isCheck() {
return this._isKingAttacked(this._turn);
}
inCheck() {
return this.isCheck();
}
isCheckmate() {
return this.isCheck() && this._moves().length === 0;
}
isStalemate() {
return !this.isCheck() && this._moves().length === 0;
}
isInsufficientMaterial() {
/*
* k.b. vs k.b. (of opposite colors) with mate in 1:
* 8/8/8/8/1b6/8/B1k5/K7 b - - 0 1
*
* k.b. vs k.n. with mate in 1:
* 8/8/8/8/1n6/8/B7/K1k5 b - - 2 1
*/
const pieces = {
b: 0,
n: 0,
r: 0,
q: 0,
k: 0,
p: 0,
};
const bishops = [];
let numPieces = 0;
let squareColor = 0;
for (let i = Ox88.a8; i <= Ox88.h1; i++) {
squareColor = (squareColor + 1) % 2;
if (i & 0x88) {
i += 7;
continue;
}
const piece = this._board[i];
if (piece) {
pieces[piece.type] =
piece.type in pieces ? pieces[piece.type] + 1 : 1;
if (piece.type === BISHOP) {
bishops.push(squareColor);
}
numPieces++;
}
}
// k vs. k
if (numPieces === 2) {
return true;
}
else if (
// k vs. kn .... or .... k vs. kb
numPieces === 3 &&
(pieces[BISHOP] === 1 || pieces[KNIGHT] === 1)) {
return true;
}
else if (numPieces === pieces[BISHOP] + 2) {
// kb vs. kb where any number of bishops are all on the same color
let sum = 0;
const len = bishops.length;
for (let i = 0; i < len; i++) {
sum += bishops[i];
}
if (sum === 0 || sum === len) {
return true;
}
}
return false;
}
isThreefoldRepetition() {
const moves = [];
const positions = {};
let repetition = false;
while (true) {
const move = this._undoMove();
if (!move)
break;
moves.push(move);
}
while (true) {
/*
* remove the last two fields in the FEN string, they're not needed when
* checking for draw by rep
*/
const fen = this.fen().split(" ").slice(0, 4).join(" ");
// has the position occurred three or move times
positions[fen] = fen in positions ? positions[fen] + 1 : 1;
if (positions[fen] >= 3) {
repetition = true;
}
const move = moves.pop();
if (!move) {
break;
}
else {
this._makeMove(move);
}
}
return repetition;
}
isDraw() {
return (this._halfMoves >= 100 || // 50 moves per side = 100 half moves
this.isStalemate() ||
this.isInsufficientMaterial() ||
this.isThreefoldRepetition());
}
isGameOver() {
return this.isCheckmate() || this.isStalemate() || this.isDraw();
}
moves({ verbose = false, square = undefined, piece = undefined, } = {}) {
const moves = this._moves({ square, piece });
if (verbose) {
return moves.map(move => this._makePretty(move));
}
else {
return moves.map(move => this._moveToSan(move, moves));
}
}
_moves({ legal = true, piece = undefined, square = undefined, } = {}) {
var _a;
const forSquare = square ? square.toLowerCase() : undefined;
const forPiece = piece === null || piece === void 0 ? void 0 : piece.toLowerCase();
const moves = [];
const us = this._turn;
const them = swapColor(us);
let firstSquare = Ox88.a8;
let lastSquare = Ox88.h1;
let singleSquare = false;
// are we generating moves for a single square?
if (forSquare) {
// illegal square, return empty moves
if (!(forSquare in Ox88)) {
return [];
}
else {
firstSquare = lastSquare = Ox88[forSquare];
singleSquare = true;
}
}
for (let from = firstSquare; from <= lastSquare; from++) {
// did we run off the end of the board
if (from & 0x88) {
from += 7;
continue;
}
// empty square or opponent, skip
if (!this._board[from] || this._board[from].color === them) {
continue;
}
const { type } = this._board[from];
let to;
if (type === PAWN) {
if (forPiece && forPiece !== type)
continue;
// single square, non-capturing
to = from + PAWN_OFFSETS[us][0];
if (!this._board[to]) {
addMove(moves, us, from, to, PAWN);
// double square
to = from + PAWN_OFFSETS[us][1];
if (SECOND_RANK[us] === rank(from) && !this._board[to]) {
addMove(moves, us, from, to, PAWN, undefined, BITS.BIG_PAWN);
}
}
// pawn captures
for (let j = 2; j < 4; j++) {
to = from + PAWN_OFFSETS[us][j];
if (to & 0x88)
continue;
if (((_a = this._board[to]) === null || _a === void 0 ? void 0 : _a.color) === them) {
addMove(moves, us, from, to, PAWN, this._board[to].type, BITS.CAPTURE);
}
else if (to === this._epSquare) {
addMove(moves, us, from, to, PAWN, PAWN, BITS.EP_CAPTURE);
}
}
}
else {
if (forPiece && forPiece !== type)
continue;
for (let j = 0, len = PIECE_OFFSETS[type].length; j < len; j++) {
const offset = PIECE_OFFSETS[type][j];
to = from;
while (true) {
to += offset;
if (to & 0x88)
break;
if (!this._board[to]) {
addMove(moves, us, from, to, type);
}
else {
// own color, stop loop
if (this._board[to].color === us)
break;
addMove(moves, us, from, to, type, this._board[to].type, BITS.CAPTURE);
break;
}
/* break, if knight or king */
if (type === KNIGHT || type === KING)
break;
}
}
}
}
/*
* check for castling if we're:
* a) generating all moves, or
* b) doing single square move generation on the king's square
*/
if (forPiece === undefined || forPiece === KING) {
if (!singleSquare || lastSquare === this._kings[us]) {
// king-side castling
if (this._castling[us] & BITS.KSIDE_CASTLE) {
const castlingFrom = this._kings[us];
const castlingTo = castlingFrom + 2;
if (!this._board[castlingFrom + 1] &&
!this._board[castlingTo] &&
!this._attacked(them, this._kings[us]) &&
!this._attacked(them, castlingFrom + 1) &&
!this._attacked(them, castlingTo)) {
addMove(moves, us, this._kings[us], castlingTo, KING, undefined, BITS.KSIDE_CASTLE);
}
}
// queen-side castling
if (this._castling[us] & BITS.QSIDE_CASTLE) {
const castlingFrom = this._kings[us];
const castlingTo = castlingFrom - 2;
if (!this._board[castlingFrom - 1] &&
!this._board[castlingFrom - 2] &&
!this._board[castlingFrom - 3] &&
!this._attacked(them, this._kings[us]) &&
!this._attacked(them, castlingFrom - 1) &&
!this._attacked(them, castlingTo)) {
addMove(moves, us, this._kings[us], castlingTo, KING, undefined, BITS.QSIDE_CASTLE);
}
}
}
}
/*
* return all pseudo-legal moves (this includes moves that allow the king
* to be captured)
*/
if (!legal) {
return moves;
}
// filter out illegal moves
const legalMoves = [];
for (let i = 0, len = moves.length; i < len; i++) {
this._makeMove(moves[i]);
if (!this._isKingAttacked(us)) {
legalMoves.push(moves[i]);
}
this._undoMove();
}
return legalMoves;
}
move(move, { strict = false } = {}) {
/*
* The move function can be called with in the following parameters:
*
* .move('Nxb7') <- argument is a case-sensitive SAN string
*
* .move({ from: 'h7', <- argument is a move object
* to :'h8',
* promotion: 'q' })
*
*
* An optional strict argument may be supplied to tell chess.js to
* strictly follow the SAN specification.
*/
let moveObj = null;
if (typeof move === "string") {
moveObj = this._moveFromSan(move, strict);
}
else if (typeof move === "object") {
const moves = this._moves();
// convert the pretty move object to an ugly move object
for (let i = 0, len = moves.length; i < len; i++) {
if (move.from === algebraic(moves[i].from) &&
move.to === algebraic(moves[i].to) &&
(!("promotion" in moves[i]) ||
move.promotion === moves[i].promotion)) {
moveObj = moves[i];
break;
}
}
}
// failed to find move
if (!moveObj) {
if (typeof move === "string") {
throw new Error(`Invalid move: ${move}`);
}
else {
throw new Error(`Invalid move: ${JSON.stringify(move)}`);
}
}
/*
* need to make a copy of move because we can't generate SAN after the move
* is made
*/
const prettyMove = this._makePretty(moveObj);
this._makeMove(moveObj);
return prettyMove;
}
_push(move) {
this._history.push({
move,
kings: { b: this._kings.b, w: this._kings.w },
turn: this._turn,
castling: { b: this._castling.b, w: this._castling.w },
epSquare: this._epSquare,
halfMoves: this._halfMoves,
moveNumber: this._moveNumber,
});
}
_makeMove(move) {
const us = this._turn;
const them = swapColor(us);
this._push(move);
this._board[move.to] = this._board[move.from];
delete this._board[move.from];
// if ep capture, remove the captured pawn
if (move.flags & BITS.EP_CAPTURE) {
if (this._turn === BLACK) {
delete this._board[move.to - 16];
}
else {
delete this._board[move.to + 16];
}
}
// if pawn promotion, replace with new piece
if (move.promotion) {
this._board[move.to] = { type: move.promotion, color: us };
}
// if we moved the king
if (this._board[move.to].type === KING) {
this._kings[us] = move.to;
// if we castled, move the rook next to the king
if (move.flags & BITS.KSIDE_CASTLE) {
const castlingTo = move.to - 1;
const castlingFrom = move.to + 1;
this._board[castlingTo] = this._board[castlingFrom];
delete this._board[castlingFrom];
}
else if (move.flags & BITS.QSIDE_CASTLE) {
const castlingTo = move.to + 1;
const castlingFrom = move.to - 2;
this._board[castlingTo] = this._board[castlingFrom];
delete this._board[castlingFrom];
}
// turn off castling
this._castling[us] = 0;
}
// turn off castling if we move a rook
if (this._castling[us]) {
for (let i = 0, len = ROOKS[us].length; i < len; i++) {
if (move.from === ROOKS[us][i].square &&
this._castling[us] & ROOKS[us][i].flag) {
this._castling[us] ^= ROOKS[us][i].flag;
break;
}
}
}
// turn off castling if we capture a rook
if (this._castling[them]) {
for (let i = 0, len = ROOKS[them].length; i < len; i++) {
if (move.to === ROOKS[them][i].square &&
this._castling[them] & ROOKS[them][i].flag) {
this._castling[them] ^= ROOKS[them][i].flag;
break;
}
}
}
// if big pawn move, update the en passant square
if (move.flags & BITS.BIG_PAWN) {
if (us === BLACK) {
this._epSquare = move.to - 16;
}
else {
this._epSquare = move.to + 16;
}
}
else {
this._epSquare = EMPTY;
}
// reset the 50 move counter if a pawn is moved or a piece is captured
if (move.piece === PAWN) {
this._halfMoves = 0;
}
else if (move.flags & (BITS.CAPTURE | BITS.EP_CAPTURE)) {
this._halfMoves = 0;
}
else {
this._halfMoves++;
}
if (us === BLACK) {
this._moveNumber++;
}
this._turn = them;
}
undo() {
const move = this._undoMove();
return move ? this._makePretty(move) : null;
}
_undoMove() {
const old = this._history.pop();
if (old === undefined) {
return null;
}
const move = old.move;
this._kings = old.kings;
this._turn = old.turn;
this._castling = old.castling;
this._epSquare = old.epSquare;
this._halfMoves = old.halfMoves;
this._moveNumber = old.moveNumber;
const us = this._turn;
const them = swapColor(us);
this._board[move.from] = this._board[move.to];
this._board[move.from].type = move.piece; // to undo any promotions
delete this._board[move.to];
if (move.captured) {
if (move.flags & BITS.EP_CAPTURE) {
// en passant capture
let index;
if (us === BLACK) {
index = move.to - 16;
}
else {
index = move.to + 16;
}
this._board[index] = { type: PAWN, color: them };
}
else {
// regular capture
this._board[move.to] = { type: move.captured, color: them };
}
}
if (move.flags & (BITS.KSIDE_CASTLE | BITS.QSIDE_CASTLE)) {
let castlingTo, castlingFrom;
if (move.flags & BITS.KSIDE_CASTLE) {
castlingTo = move.to + 1;
castlingFrom = move.to - 1;
}
else {
castlingTo = move.to - 2;
castlingFrom = move.to + 1;
}
this._board[castlingTo] = this._board[castlingFrom];
delete this._board[castlingFrom];
}
return move;
}
pgn({ newline = "\n", maxWidth = 0, } = {}) {
/*
* using the specification from http://www.chessclub.com/help/PGN-spec
* example for html usage: .pgn({ max_width: 72, newline_char: "<br />" })
*/
const result = [];
let headerExists = false;
/* add the PGN header information */
for (const i in this._header) {
/*
* TODO: order of enumerated properties in header object is not
* guaranteed, see ECMA-262 spec (section 12.6.4)
*/
result.push("[" + i + ' "' + this._header[i] + '"]' + newline);
headerExists = true;
}
if (headerExists && this._history.length) {
result.push(newline);
}
const appendComment = (moveString) => {
const comment = this._comments[this.fen()];
if (typeof comment !== "undefined") {
const delimiter = moveString.length > 0 ? " " : "";
moveString = `${moveString}${delimiter}{${comment}}`;
}
return moveString;
};
// pop all of history onto reversed_history
const reversedHistory = [];
while (this._history.length > 0) {
reversedHistory.push(this._undoMove());
}
const moves = [];
let moveString = "";
// special case of a commented starting position with no moves
if (reversedHistory.length === 0) {
moves.push(appendComment(""));
}
// build the list of moves. a move_string looks like: "3. e3 e6"
while (reversedHistory.length > 0) {
moveString = appendComment(moveString);
const move = reversedHistory.pop();
// make TypeScript stop complaining about move being undefined
if (!move) {
break;
}
// if the position started with black to move, start PGN with #. ...
if (!this._history.length && move.color === "b") {
const prefix = `${this._moveNumber}. ...`;
// is there a comment preceding the first move?
moveString = moveString ? `${moveString} ${prefix}` : prefix;
}
else if (move.color === "w") {
// store the previous generated move_string if we have one
if (moveString.length) {
moves.push(moveString);
}
moveString = this._moveNumber + ".";
}
moveString =
moveString +
" " +
this._moveToSan(move, this._moves({ legal: true }));
this._makeMove(move);
}
// are there any other leftover moves?
if (moveString.length) {
moves.push(appendComment(moveString));
}
// is there a result?
if (typeof this._header.Result !== "undefined") {
moves.push(this._header.Result);
}
/*
* history should be back to what it was before we started generating PGN,
* so join together moves
*/
if (maxWidth === 0) {
return result.join("") + moves.join(" ");
}
// TODO (jah): huh?
const strip = function () {
if (result.length > 0 && result[result.length - 1] === " ") {
result.pop();
return true;
}
return false;
};
// NB: this does not preserve comment whitespace.
const wrapComment = function (width, move) {
for (const token of move.split(" ")) {
if (!token) {
continue;
}
if (width + token.length > maxWidth) {
while (strip()) {
width--;
}
result.push(newline);
width = 0;
}
result.push(token);
width += token.length;
result.push(" ");
width++;
}
if (strip()) {
width--;
}
return width;
};
// wrap the PGN output at max_width
let currentWidth = 0;
for (let i = 0; i < moves.length; i++) {
if (currentWidth + moves[i].length > maxWidth) {
if (moves[i].includes("{")) {
currentWidth = wrapComment(currentWidth, moves[i]);
continue;
}
}
// if the current move will push past max_width
if (currentWidth + moves[i].length > maxWidth && i !== 0) {
// don't end the line with whitespace
if (result[result.length - 1] === " ") {
result.pop();
}
result.push(newline);
currentWidth = 0;
}
else if (i !== 0) {
result.push(" ");
currentWidth++;
}
result.push(moves[i]);
currentWidth += moves[i].length;
}
return result.join("");
}
header(...args) {
for (let i = 0; i < args.length; i += 2) {
if (typeof args[i] === "string" &&
typeof args[i + 1] === "string") {
this._header[args[i]] = args[i + 1];
}
}
return this._header;
}
loadPgn(pgn, { strict = false, newlineChar = "\r?\n", } = {}) {
function mask(str) {
return str.replace(/\\/g, "\\");
}
function parsePgnHeader(header) {
const headerObj = {};
const headers = header.split(new RegExp(mask(newlineChar)));
let key = "";
let value = "";
for (let i = 0; i < headers.length; i++) {
const regex = /^\s*\[\s*([A-Za-z]+)\s*"(.*)"\s*\]\s*$/;
key = headers[i].replace(regex, "$1");
value = headers[i].replace(regex, "$2");
if (key.trim().length > 0) {
headerObj[key] = value;
}
}
return headerObj;
}
// strip whitespace from head/tail of PGN block
pgn = pgn.trim();
/*
* RegExp to split header. Takes advantage of the fact that header and movetext
* will always have a blank line between them (ie, two newline_char's). Handles
* case where movetext is empty by matching newlineChar until end of string is
* matched - effectively trimming from the end extra newlineChar.
*
* With default newline_char, will equal:
* /^(\[((?:\r?\n)|.)*\])((?:\s*\r?\n){2}|(?:\s*\r?\n)*$)/
*/
const headerRegex = new RegExp("^(\\[((?:" +
mask(newlineChar) +
")|.)*\\])" +
"((?:\\s*" +
mask(newlineChar) +
"){2}|(?:\\s*" +
mask(newlineChar) +
")*$)");
// If no header given, begin with moves.
const headerRegexResults = headerRegex.exec(pgn);
const headerString = headerRegexResults
? headerRegexResults.length >= 2
? headerRegexResults[1]
: ""
: "";
// Put the board in the starting position
this.reset();
// parse PGN header
const headers = parsePgnHeader(headerString);
let fen = "";
for (const key in headers) {
// check to see user is including fen (possibly with wrong tag case)
if (key.toLowerCase() === "fen") {
fen = headers[key];
}
this.header(key, headers[key]);
}
/*
* the permissive parser should attempt to load a fen tag, even if it's the
* wrong case and doesn't include a corresponding [SetUp "1"] tag
*/
if (!strict) {
if (fen) {
this.load(fen, true);
}
}
else {
/*
* strict parser - load the starting position indicated by [Setup '1']
* and [FEN position]
*/
if (headers["SetUp"] === "1") {
if (!("FEN" in headers)) {
throw new Error("Invalid PGN: FEN tag must be supplied with SetUp tag");
}
// second argument to load: don't clear the headers
this.load(headers["FEN"], true);
}
}
/*
* NB: the regexes below that delete move numbers, recursive annotations,
* and numeric annotation glyphs may also match text in comments. To
* prevent this, we transform comments by hex-encoding them in place and
* decoding them again after the other tokens have been deleted.
*
* While the spec states that PGN files should be ASCII encoded, we use
* {en,de}codeURIComponent here to support arbitrary UTF8 as a convenience
* for modern users
*/
function toHex(s) {
return Array.from(s)
.map(function (c) {
/*
* encodeURI doesn't transform most ASCII characters, so we handle
* these ourselves
*/
return c.charCodeAt(0) < 128
? c.charCodeAt(0).toString(16)
: encodeURIComponent(c).replace(/%/g, "").toLowerCase();
})
.join("");
}
function fromHex(s) {
return s.length == 0
? ""
: decodeURIComponent("%" + (s.match(/.{1,2}/g) || []).join("%"));
}
const encodeComment = function (s) {
s = s.replace(new RegExp(mask(newlineChar), "g"), " ");
return `{${toHex(s.slice(1, s.length - 1))}}`;
};
const decodeComment = function (s) {
if (s.startsWith("{") && s.endsWith("}")) {
return fromHex(s.slice(1, s.length - 1));
}
};
// delete header to get the moves
let ms = pgn
.replace(headerString, "")
.replace(
// encode comments so they don't get deleted below
new RegExp(`({[^}]*})+?|;([^${mask(newlineChar)}]*)`, "g"), function (_match, bracket, semicolon) {
return bracket !== undefined
? encodeComment(bracket)
: " " + encodeComment(`{${semicolon.slice(1)}}`);
})
.replace(new RegExp(mask(newlineChar), "g"), " ");
// delete recursive annotation variations
const ravRegex = /(\([^()]+\))+?/g;
while (ravRegex.test(ms)) {
ms = ms.replace(ravRegex, "");
}
// delete move numbers
ms = ms.replace(/\d+\.(\.\.)?/g, "");
// delete ... indicating black to move
ms = ms.replace(/\.\.\./g, "");
/* delete numeric annotation glyphs */
ms = ms.replace(/\$\d+/g, "");
// trim and get array of moves
let moves = ms.trim().split(new RegExp(/\s+/));
// delete empty entries
moves = moves.filter(move => move !== "");
let result = "";
for (let halfMove = 0; halfMove < moves.length; halfMove++) {
const comment = decodeComment(moves[halfMove]);
if (comment !== undefined) {
this._comments[this.fen()] = comment;
continue;
}
const move = this._moveFromSan(moves[halfMove], strict);
// invalid move
if (move == null) {
// was the move an end of game marker
if (TERMINATION_MARKERS.indexOf(moves[halfMove]) > -1) {
result = moves[halfMove];
}
else {
throw new Error(`Invalid move in PGN: ${moves[halfMove]}`);
}
}
else {
// reset the end of game marker if making a valid move
result = "";
this._makeMove(move);
}
}
/*
* Per section 8.2.6 of the PGN spec, the Result tag pair must match match
* the termination marker. Only do this when headers are present, but the
* result tag is missing
*/
if (result &&
Object.keys(this._header).length &&
!this._header["Result"]) {
this.header("Result", result);
}
}
/*
* Convert a move from 0x88 coordinates to Standard Algebraic Notation
* (SAN)
*
* @param {boolean} strict Use the strict SAN parser. It will throw errors
* on overly disambiguated moves (see below):
*
* r1bqkbnr/ppp2ppp/2n5/1B1pP3/4P3/8/PPPP2PP/RNBQK1NR b KQkq - 2 4
* 4. ... Nge7 is overly disambiguated because the knight on c6 is pinned
* 4. ... Ne7 is technically the valid SAN
*/
_moveToSan(move, moves) {
let output = "";
if (move.flags & BITS.KSIDE_CASTLE) {
output = "O-O";
}
else if (move.flags & BITS.QSIDE_CASTLE) {
output = "O-O-O";
}
else {
if (move.piece !== PAWN) {
const disambiguator = getDisambiguator(move, moves);
output += move.piece.toUpperCase() + disambiguator;
}
if (move.flags & (BITS.CAPTURE | BITS.EP_CAPTURE)) {
if (move.piece === PAWN) {
output += algebraic(move.from)[0];
}
output += "x";
}
output += algebraic(move.to);
if (move.promotion) {
output += "=" + move.promotion.toUpperCase();
}
}
this._makeMove(move);
if (this.isCheck()) {
if (this.isCheckmate()) {
output += "#";
}
else {
output += "+";
}
}
this._undoMove();
return output;
}
// convert a move from Standard Algebraic Notation (SAN) to 0x88 coordinates
_moveFromSan(move, strict = false) {
// strip off any move decorations: e.g Nf3+?! becomes Nf3
const cleanMove = strippedSan(move);
let pieceType = inferPieceType(cleanMove);
let moves = this._moves({ legal: true, piece: pieceType });
// strict parser
for (let i = 0, len = moves.length; i < len; i++) {
if (cleanMove === strippedSan(this._moveToSan(moves[i], moves))) {
return moves[i];
}
}
// the strict parser failed
if (strict) {
return null;
}
let piece = undefined;
let matches = undefined;
let from = undefined;
let to = undefined;
let promotion = undefined;
/*
* The default permissive (non-strict) parser allows the user to parse
* non-standard chess notations. This parser is only run after the strict
* Standard Algebraic Notation (SAN) parser has failed.
*
* When running the permissive parser, we'll run a regex to grab the piece, the
* to/from square, and an optional promotion piece. This regex will
* parse common non-standard notation like: Pe2-e4, Rc1c4, Qf3xf7,
* f7f8q, b1c3
*
* NOTE: Some positions and moves may be ambiguous when using the permissive
* parser. For example, in this position: 6k1/8/8/B7/8/8/8/BN4K1 w - - 0 1,
* the move b1c3 may be interpreted as Nc3 or B1c3 (a disambiguated bishop
* move). In these cases, the permissive parser will default to the most
* basic interpretation (which is b1c3 parsing to Nc3).
*/
let overlyDisambiguated = false;
matches = cleanMove.match(/([pnbrqkPNBRQK])?([a-h][1-8])x?-?([a-h][1-8])([qrbnQRBN])?/
// piece from to promotion
);
if (matches) {
piece = matches[1];
from = matches[2];
to = matches[3];
promotion = matches[4];
if (from.length == 1) {
overlyDisambiguated = true;
}
}
else {
/*
* The [a-h]?[1-8]? portion of the regex below handles moves that may be
* overly disambiguated (e.g. Nge7 is unnecessary and non-standard when
* there is one legal knight move to e7). In this case, the value of
* 'from' variable will be a rank or file, not a square.
*/
matches = cleanMove.match(/([pnbrqkPNBRQK])?([a-h]?[1-8]?)x?-?([a-h][1-8])([qrbnQRBN])?/);
if (matches) {
piece = matches[1];
from = matches[2];
to = matches[3];
promotion = matches[4];
if (from.length == 1) {
overlyDisambiguated = true;
}
}
}
pieceType = inferPieceType(cleanMove);
moves = this._moves({
legal: true,
piece: piece ? piece : pieceType,
});
for (let i = 0, len = moves.length; i < len; i++) {
if (from && to) {
// hand-compare move properties with the results from our permissive regex
if ((!piece || piece.toLowerCase() == moves[i].piece) &&
Ox88[from] == moves[i].from &&
Ox88[to] == moves[i].to &&
(!promotion ||
promotion.toLowerCase() == moves[i].promotion)) {
return moves[i];
}
else if (overlyDisambiguated) {
/*
* SPECIAL CASE: we parsed a move string that may have an unneeded
* rank/file disambiguator (e.g. Nge7). The 'from' variable will
*/
const square = algebraic(moves[i].from);
if ((!piece || piece.toLowerCase() == moves[i].piece) &&
Ox88[to] == moves[i].to &&
(from == square[0] || from == square[1]) &&
(!promotion ||
promotion.toLowerCase() == moves[i].promotion)) {
return moves[i];
}
}
}
}
return null;
}
ascii() {
let s = " +------------------------+\n";
for (let i = Ox88.a8; i <= Ox88.h1; i++) {
// display the rank
if (file(i) === 0) {
s += " " + "87654321"[rank(i)] + " |";
}
if (this._board[i]) {
const piece = this._board[i].type;
const color = this._board[i].color;
const symbol = color === WHITE ? piece.toUpperCase() : piece.toLowerCase();
s += " " + symbol + " ";
}
else {
s += " . ";
}
if ((i + 1) & 0x88) {
s += "|\n";
i += 8;
}
}
s += " +------------------------+\n";
s += " a b c d e f g h";
return s;
}
perft(depth) {
const moves = this._moves({ legal: false });
let nodes = 0;
const color = this._turn;
for (let i = 0, len = moves.length; i < len; i++) {
this._makeMove(moves[i]);
if (!this._isKingAttacked(color)) {
if (depth - 1 > 0) {
nodes += this.perft(depth - 1);
}
else {
nodes++;
}
}
this._undoMove();
}
return nodes;
}
// pretty = external move object
_makePretty(uglyMove) {
const { color, piece, from, to, flags, captured, promotion } = uglyMove;
let prettyFlags = "";
for (const flag in BITS) {
if (BITS[flag] & flags) {
prettyFlags += FLAGS[flag];
}
}
const fromAlgebraic = algebraic(from);
const toAlgebraic = algebraic(to);
const move = {
color,
piece,
from: fromAlgebraic,
to: toAlgebraic,
san: this._moveToSan(uglyMove, this._moves({ legal: true })),
flags: prettyFlags,
lan: fromAlgebraic + toAlgebraic,
before: this.fen(),
after: "",
};
// generate the FEN for the 'after' key
this._makeMove(uglyMove);
move.after = this.fen();
this._undoMove();
if (captured) {
move.captured = captured;
}
if (promotion) {
move.promotion = promotion;
move.lan += promotion;
}
return move;
}
turn() {
return this._turn;
}
board() {
const output = [];
let row = [];
for (let i = Ox88.a8; i <= Ox88.h1; i++) {
if (!this._board[i]) {
row.push(false);
}
else {
row.push({
square: algebraic(i),
type: this._board[i].type,
color: this._board[i].color,
});
}
if ((i + 1) & 0x88) {
output.push(row);
row = [];
i += 8;
}
}
return output;
}
squareColor(square) {
if (square in Ox88) {
const sq = Ox88[square];
return (rank(sq) + file(sq)) % 2 === 0 ? "w" : "b";
}
return null;
}
history({ verbose = false } = {}) {
const reversedHistory = [];
const moveHistory = [];
while (this._history.length > 0) {
reversedHistory.push(this._undoMove());
}
while (true) {
const move = reversedHistory.pop();
if (!move) {
break;
}
if (verbose) {
moveHistory.push(this._makePretty(move));
}
else {
moveHistory.push(this._moveToSan(move, this._moves()));
}
this._makeMove(move);
}
return moveHistory;
}
_pruneComments() {
const reversedHistory = [];
const currentComments = {};
const copyComment = (fen) => {
if (fen in this._comments) {
currentComments[fen] = this._comments[fen];
}
};
while (this._history.length > 0) {
reversedHistory.push(this._undoMove());
}
copyComment(this.fen());
while (true) {
const move = reversedHistory.pop();
if (!move) {
break;
}
this._makeMove(move);
copyComment(this.fen());
}
this._comments = currentComments;
}
getComment() {
return this._comments[this.fen()];
}
setComment(comment) {
this._comments[this.fen()] = comment
.replace("{", "[")
.replace("}", "]");
}
deleteComment() {
const comment = this._comments[this.fen()];
delete this._comments[this.fen()];
return comment;
}
getComments() {
this._pruneComments();
return Object.keys(this._comments).map((fen) => {
return { fen: fen, comment: this._comments[fen] };
});
}
deleteComments() {
this._pruneComments();
return Object.keys(this._comments).map(fen => {
const comment = this._comments[fen];
delete this._comments[fen];
return { fen: fen, comment: comment };
});
}
}
Reference in a new issue Copy permalink