chess-tactics 0.0.1

package/dist/utils/TacticHeuristics.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attackingSquareIsGood = attackingSquareIsGood;
+exports.attackingSquareIsBad = attackingSquareIsBad;
+exports.materialAdvantageAfterTradesAtSquare = materialAdvantageAfterTradesAtSquare;
+exports.getEscapeSquares = getEscapeSquares;
+exports.getBlockingMoves = getBlockingMoves;
+exports.getMovesToSquare = getMovesToSquare;
+exports.getThreateningMoves = getThreateningMoves;
+const chess_js_1 = require("chess.js");
+const _utils_1 = require("./index");
+function attackingSquareIsGood(fen, square, startingMove = null) {
+    const advantage = materialAdvantageAfterTradesAtSquare(fen, square, startingMove);
+    const color = (0, _utils_1.colorToPlay)(fen);
+    if (color === "w") {
+        return advantage > 0;
+    }
+    return advantage < 0;
+}
+function attackingSquareIsBad(fen, square, startingMove = null) {
+    const advantage = materialAdvantageAfterTradesAtSquare(fen, square, startingMove);
+    const color = (0, _utils_1.colorToPlay)(fen);
+    if (color === "w") {
+        return advantage < 0;
+    }
+    return advantage > 0;
+}
+function materialAdvantageAfterTradesAtSquare(position, square, startingMove = null) {
+    const chess = new chess_js_1.Chess(position);
+    let score = 0;
+    if (startingMove) {
+        chess.move(startingMove);
+        if (startingMove.captured) {
+            if (chess.turn() === "w") {
+                score -= _utils_1.PIECE_VALUES[startingMove.captured];
+            }
+            else {
+                score += _utils_1.PIECE_VALUES[startingMove.captured];
+            }
+        }
+    }
+    return helper(chess, square, score);
+}
+function helper(chess, square, score) {
+    if (chess.turn() === "w" && score > 0)
+        return score;
+    if (chess.turn() === "b" && score < 0)
+        return score;
+    const possibleMoves = chess.moves({ verbose: true }).filter((m) => m.to === square);
+    if (possibleMoves.length === 0)
+        return score;
+    const leastMaterialMove = possibleMoves.sort((a, b) => _utils_1.PIECE_VALUES[a.piece] - _utils_1.PIECE_VALUES[b.piece]);
+    const move = chess.move(leastMaterialMove[0]);
+    if (chess.turn() === "w") {
+        score -= _utils_1.PIECE_VALUES[move.captured];
+    }
+    else {
+        score += _utils_1.PIECE_VALUES[move.captured];
+    }
+    return helper(chess, square, score);
+}
+function getEscapeSquares(fen, square) {
+    const chess = new chess_js_1.Chess(fen);
+    const piece = chess.get(square);
+    if (!piece) {
+        throw new Error("function called on a square that is unoccupied!");
+    }
+    const moves = chess.moves({ square, verbose: true });
+    const escapeSquares = [];
+    for (let i = 0; i < moves.length; i++) {
+        if (!attackingSquareIsBad(fen, moves[i].to, moves[i])) {
+            escapeSquares.push(moves[i].to);
+        }
+    }
+    return escapeSquares;
+}
+function getBlockingMoves(fen, attackingSquare, threatenedSquare) {
+    if (squaresAreNeighbors(attackingSquare, threatenedSquare)) {
+        return [];
+    }
+    const chess = new chess_js_1.Chess(fen);
+    const attackingPiece = chess.get(attackingSquare);
+    const threatenedPiece = chess.get(threatenedSquare);
+    if (!attackingPiece || !threatenedPiece) {
+        throw new Error(`The squares ${attackingSquare} or ${threatenedSquare} do not have pieces on them`);
+    }
+    if (attackingPiece.color === chess.turn()) {
+        throw new Error("It should not be attacker's turn to move!");
+    }
+    if (threatenedPiece.color !== chess.turn()) {
+        throw new Error("It needs to be defender's turn to move!");
+    }
+    chess.load((0, _utils_1.setTurn)(chess.fen(), attackingPiece.color));
+    if (chess
+        .moves({ square: attackingSquare, verbose: true })
+        .filter((m) => m.to === threatenedSquare).length === 0) {
+        throw new Error("attackingSquare doesn't even threaten threatenedSquare");
+    }
+    chess.load((0, _utils_1.setTurn)(chess.fen(), threatenedPiece.color));
+    const candidateMoves = chess
+        .moves({ verbose: true })
+        .filter((m) => m.from !== threatenedSquare)
+        .filter((m) => {
+        const chessCopy = new chess_js_1.Chess(fen);
+        chessCopy.move(m);
+        return (chessCopy
+            .moves({ square: attackingSquare, verbose: true })
+            .filter((n) => n.to === threatenedSquare).length === 0);
+    });
+    const blockingMoves = [];
+    for (let i = 0; i < candidateMoves.length; i++) {
+        chess.load(fen);
+        chess.move(candidateMoves[i]);
+        let initialAdvantage = 0;
+        const captured = candidateMoves[i].captured;
+        if (captured) {
+            initialAdvantage = _utils_1.PIECE_VALUES[captured];
+        }
+        const opponentAdvantage = materialAdvantageAfterTradesAtSquare(chess.fen(), candidateMoves[i].to);
+        if (initialAdvantage - opponentAdvantage >= 0) {
+            blockingMoves.push({ from: candidateMoves[i].from, to: candidateMoves[i].to });
+        }
+    }
+    return blockingMoves;
+}
+function squaresAreNeighbors(sq1, sq2) {
+    if (sq1 === sq2)
+        return false;
+    const x1 = sq1.charCodeAt(0);
+    const y1 = parseInt(sq1[1], 10);
+    const x2 = sq2.charCodeAt(0);
+    const y2 = parseInt(sq2[1], 10);
+    const deltaX = Math.abs(x1 - x2);
+    const deltaY = Math.abs(y1 - y2);
+    return deltaX <= 1 && deltaY <= 1;
+}
+function getMovesToSquare(fen, square) {
+    const chess = new chess_js_1.Chess(fen, { skipValidation: true });
+    const piece = chess.get(square);
+    if (piece && piece.color === chess.turn()) {
+        throw new Error("Provided a square that is occupied by a piece of the player to play. This could cause unexpected behavior");
+    }
+    const pieceMoves = chess
+        .moves({ verbose: true })
+        .filter((m) => m.to === square && m.piece !== "p");
+    const pawnMoves = pawnsDefendingSquare(fen, square, chess.turn());
+    chess.load(fen, { skipValidation: true });
+    return pieceMoves.concat(pawnMoves);
+}
+function pawnsDefendingSquare(fen, square, color) {
+    const chess = new chess_js_1.Chess((0, _utils_1.setTurn)(fen, color), { skipValidation: true });
+    chess.put({ type: "q", color: color === "w" ? "b" : "w" }, square);
+    chess.setTurn(color);
+    const result = chess.moves({ verbose: true }).filter((m) => m.to === square && m.piece === "p");
+    return result;
+}
+function getThreateningMoves(position, currentMove) {
+    // game must be the initial position
+    const chess = new chess_js_1.Chess(position);
+    chess.move(currentMove);
+    (0, _utils_1.invertTurn)(chess);
+    const possibleMoves = chess.moves({ square: currentMove.to, verbose: true });
+    const threateningMoves = [];
+    for (const m of possibleMoves) {
+        for (const n of possibleMoves) {
+            if (n.captured !== "k" && n.to !== m.to)
+                chess.remove(n.to);
+        }
+        if (m.captured && attackingSquareIsGood(chess.fen(), m.to, m)) {
+            threateningMoves.push(m);
+        }
+        chess.load(position);
+        chess.move(currentMove);
+        (0, _utils_1.invertTurn)(chess);
+    }
+    return threateningMoves;
+}

package/dist/utils/Utils.d.ts

@@ -0,0 +1,18 @@
+import { PieceSymbol, Color, Chess, Move } from "chess.js";
+import { Fen } from "../types";
+export declare function isWhiteToPlay(x: number | string): boolean;
+export declare function setTurn(position: Fen, color: Color): string;
+export declare function invertTurn(chess: Chess): void;
+export declare function colorToPlay(x: number | string): Color;
+export declare function sanToUci(position: Fen, san: string): string;
+export declare function uciToSan(position: Fen, uci: string): string;
+export declare function uciToMove(position: Fen, uci: string): Move;
+export declare function sanToMove(position: Fen, san: string): Move;
+export declare function moveToUci(move: Move | {
+    from: string;
+    to: string;
+}): string;
+export declare function materialValueInPosition(position: Fen): Record<Color, number>;
+export declare function pieceCountsInPosition(position: Fen): Record<Color, Record<PieceSymbol, number>>;
+export declare function getMaterialChange(startFen: Fen, endFen: Fen, pieceColor: Color | string): number;
+export declare function getMoveDiff(originalMoves: Move[], newMoves: Move[]): Move[];

package/dist/utils/Utils.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWhiteToPlay = isWhiteToPlay;
+exports.setTurn = setTurn;
+exports.invertTurn = invertTurn;
+exports.colorToPlay = colorToPlay;
+exports.sanToUci = sanToUci;
+exports.uciToSan = uciToSan;
+exports.uciToMove = uciToMove;
+exports.sanToMove = sanToMove;
+exports.moveToUci = moveToUci;
+exports.materialValueInPosition = materialValueInPosition;
+exports.pieceCountsInPosition = pieceCountsInPosition;
+exports.getMaterialChange = getMaterialChange;
+exports.getMoveDiff = getMoveDiff;
+const chess_js_1 = require("chess.js");
+const constants_1 = require("./constants");
+function isWhiteToPlay(x) {
+    if (typeof x === "number") {
+        return x % 2 === 0;
+    }
+    else {
+        return x.split(" ")[1] === "w";
+    }
+}
+// Note: this is needed over chess.setTurn because it allows color change when in check
+function setTurn(position, color) {
+    let fenSplit = position.split(" ");
+    fenSplit[1] = color;
+    fenSplit[3] = "-";
+    return fenSplit.join(" ");
+}
+function invertTurn(chess) {
+    let fenSplit = chess.fen().split(" ");
+    fenSplit[1] = fenSplit[1] === "w" ? "b" : "w";
+    fenSplit[3] = "-";
+    chess.load(fenSplit.join(" "));
+}
+function colorToPlay(x) {
+    const isWhite = isWhiteToPlay(x);
+    return isWhite ? "w" : "b";
+}
+function sanToUci(position, san) {
+    const m = sanToMove(position, san);
+    return `${m.from}${m.to}`;
+}
+function uciToSan(position, uci) {
+    const m = uciToMove(position, uci);
+    return m.san;
+}
+function uciToMove(position, uci) {
+    const chess = new chess_js_1.Chess(position);
+    return chess.move(uci);
+}
+function sanToMove(position, san) {
+    const chess = new chess_js_1.Chess(position);
+    return chess.move(san);
+}
+function moveToUci(move) {
+    return `${move.from}${move.to}`;
+}
+function materialValueInPosition(position) {
+    const pieceCounts = pieceCountsInPosition(position);
+    const values = { w: 0, b: 0 };
+    for (const [color, pieces] of Object.entries(pieceCounts)) {
+        for (const [piece, count] of Object.entries(pieces)) {
+            if (piece !== "k") {
+                values[color] += constants_1.PIECE_VALUES[piece] * count;
+            }
+        }
+    }
+    return values;
+}
+function pieceCountsInPosition(position) {
+    const counts = {
+        w: { p: 0, b: 0, n: 0, q: 0, r: 0, k: 0 },
+        b: { p: 0, b: 0, n: 0, q: 0, r: 0, k: 0 },
+    };
+    const pieces = position.split(" ")[0];
+    for (const p of pieces) {
+        if (!Object.keys(counts.w).includes(p.toLowerCase())) {
+            continue;
+        }
+        const pieceKey = p.toLowerCase();
+        if (p === pieceKey) {
+            counts.b[pieceKey] += 1;
+        }
+        else {
+            counts.w[pieceKey] += 1;
+        }
+    }
+    return counts;
+}
+function getMaterialChange(startFen, endFen, pieceColor) {
+    const startMaterial = materialValueInPosition(startFen);
+    const endMaterial = materialValueInPosition(endFen);
+    const startAdvantageWhite = startMaterial.w - startMaterial.b;
+    const endAdvantageWhite = endMaterial.w - endMaterial.b;
+    if (pieceColor === "w") {
+        return endAdvantageWhite - startAdvantageWhite;
+    }
+    return startAdvantageWhite - endAdvantageWhite;
+}
+function getMoveDiff(originalMoves, newMoves) {
+    return newMoves.filter((m) => originalMoves.map((n) => n.to).includes(m.to) === false && m.captured);
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,5 @@
+import { PieceSymbol } from "chess.js";
+import { TacticKey, TacticOptions } from "../types";
+export declare const PIECE_VALUES: Record<PieceSymbol, number>;
+export declare const DEFAULT_TACTIC_OPTIONS: TacticOptions;
+export declare const DEFAULT_TACTIC_CLASSIFIERS: TacticKey[];

package/dist/utils/constants.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TACTIC_CLASSIFIERS = exports.DEFAULT_TACTIC_OPTIONS = exports.PIECE_VALUES = void 0;
+exports.PIECE_VALUES = {
+    p: 1,
+    n: 3,
+    b: 3,
+    r: 5,
+    q: 9,
+    k: Infinity,
+};
+exports.DEFAULT_TACTIC_OPTIONS = {
+    trimEndSequence: false,
+};
+exports.DEFAULT_TACTIC_CLASSIFIERS = [
+    "fork",
+    "pin",
+    "sacrifice",
+    "skewer",
+    "trap",
+    "hanging",
+];

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export { SequenceInterpreter } from "./SequenceInterpreter";
+export * from "./TacticHeuristics";
+export * from "./Utils";
+export { TacticContextParser } from "./TacticContextParser";
+export * from "./constants";

package/dist/utils/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TacticContextParser = exports.SequenceInterpreter = void 0;
+var SequenceInterpreter_1 = require("./SequenceInterpreter");
+Object.defineProperty(exports, "SequenceInterpreter", { enumerable: true, get: function () { return SequenceInterpreter_1.SequenceInterpreter; } });
+__exportStar(require("./TacticHeuristics"), exports);
+__exportStar(require("./Utils"), exports);
+var TacticContextParser_1 = require("./TacticContextParser");
+Object.defineProperty(exports, "TacticContextParser", { enumerable: true, get: function () { return TacticContextParser_1.TacticContextParser; } });
+__exportStar(require("./constants"), exports);

package/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "chess-tactics",
+    "version": "0.0.1",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "build": "rm -rf dist && tsc -p tsconfig.build.json && tsc-alias"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "GPL-3.0-or-later",
+    "description": "",
+    "dependencies": {
+        "chess.js": "^1.4.0"
+    },
+    "devDependencies": {
+        "@types/jest": "^30.0.0",
+        "jest": "^30.2.0",
+        "ts-jest": "^29.4.6",
+        "ts-node": "^10.9.2",
+        "tsc-alias": "^1.8.16"
+    }
+}