chess-tactics 0.0.1

package/dist/tactics/Skewer.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkewerTactics = void 0;
+const chess_js_1 = require("chess.js");
+const _utils_1 = require("../utils/index");
+const _tactics_1 = require("./index");
+class SkewerTactics extends _tactics_1.BaseTactic {
+    isTactic(context) {
+        const { position, evaluation } = context;
+        const chess = new chess_js_1.Chess(position);
+        const currentMove = chess.move(evaluation.sequence[0]);
+        const cosmeticSkewers = this.getCosmeticSkewers(context);
+        for (const [nextMoveWithPiece, nextMoveWithoutPiece] of cosmeticSkewers) {
+            const tacticalSequence = this.sequenceInterpreter.identifyWinningSequence([currentMove.to], [nextMoveWithPiece.to, nextMoveWithoutPiece.to]);
+            if (tacticalSequence) {
+                return {
+                    type: "skewer",
+                    attackedPieces: [
+                        { square: nextMoveWithPiece.to, piece: chess.get(nextMoveWithPiece.to) },
+                        {
+                            square: nextMoveWithoutPiece.to,
+                            piece: chess.get(nextMoveWithoutPiece.to),
+                        },
+                    ],
+                    ...tacticalSequence,
+                };
+            }
+        }
+        return null;
+    }
+    getCosmeticSkewers(context) {
+        const { evaluation, position } = context;
+        const currentMove = evaluation.sequence[0];
+        if (["p", "k", "n"].includes(currentMove.piece)) {
+            return [];
+        }
+        const chess = new chess_js_1.Chess(position);
+        chess.move(currentMove);
+        // On the next turn where can you move this piece
+        (0, _utils_1.invertTurn)(chess);
+        const possibleNextMoves = chess.moves({ square: currentMove.to, verbose: true });
+        const cosmeticSkewers = [];
+        for (const move of possibleNextMoves) {
+            if (!move.captured || move.captured === currentMove.piece) {
+                continue;
+            }
+            // Return to on next turn position and remove the piece
+            chess.load(position);
+            chess.move(currentMove);
+            if (move.captured === "k") {
+                if (evaluation.sequence.length === 1) {
+                    return [];
+                }
+                const response = evaluation.sequence[1];
+                if (response.piece !== "k") {
+                    return [];
+                }
+                chess.move(response);
+            }
+            else {
+                chess.remove(move.to);
+                (0, _utils_1.invertTurn)(chess);
+            }
+            const possibleNextMovesWithoutPiece = chess.moves({
+                square: currentMove.to,
+                verbose: true,
+            });
+            const newMoves = (0, _utils_1.getMoveDiff)(possibleNextMoves, possibleNextMovesWithoutPiece);
+            for (const m of newMoves) {
+                // can you capture behind the piece in front, and is the piece in front more valuable
+                if (m.captured &&
+                    _utils_1.PIECE_VALUES[move.captured] > _utils_1.PIECE_VALUES[m.captured] &&
+                    !(0, _utils_1.attackingSquareIsBad)(chess.fen(), m.to)) {
+                    cosmeticSkewers.push([move, m]);
+                }
+            }
+        }
+        return cosmeticSkewers;
+    }
+}
+exports.SkewerTactics = SkewerTactics;

package/dist/tactics/Trap.d.ts

@@ -0,0 +1,12 @@
+import { Move } from "chess.js";
+import { Fen, Tactic } from "../types";
+import { BaseTactic } from "./index";
+import { _DefaultTacticContext } from "src/_types";
+declare class TrapTactics extends BaseTactic {
+    isTactic(context: _DefaultTacticContext): Partial<Tactic> | null;
+    getCosmeticTrap(position: Fen, currentMove: Move): any | null;
+    private pieceIsTrapped;
+    private getCapturablePieces;
+    private piecePinnedToKing;
+}
+export { TrapTactics };

package/dist/tactics/Trap.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrapTactics = void 0;
+const chess_js_1 = require("chess.js");
+const _utils_1 = require("../utils/index");
+const _tactics_1 = require("./index");
+class TrapTactics extends _tactics_1.BaseTactic {
+    isTactic(context) {
+        const { position, evaluation } = context;
+        const chess = new chess_js_1.Chess(position);
+        const currentMove = chess.move(evaluation.sequence[0]);
+        const cosmeticTrap = this.getCosmeticTrap(position, currentMove);
+        const tacticalSequence = this.sequenceInterpreter.identifyWinningSequence([currentMove.to], cosmeticTrap?.trappingSquares ?? []);
+        if (tacticalSequence) {
+            return {
+                type: "trap",
+                attackedPieces: [{ square: currentMove.to, piece: chess.get(currentMove.to) }],
+                ...tacticalSequence,
+            };
+        }
+        return null;
+    }
+    getCosmeticTrap(position, currentMove) {
+        const chess = new chess_js_1.Chess(position);
+        const capturingMoves = this.getCapturablePieces(currentMove, position);
+        // the position after currentMove is a check
+        if (capturingMoves.filter((m) => m.captured === "k").length > 0)
+            return null;
+        for (let i = 0; i < capturingMoves.length; i++) {
+            chess.load(position);
+            chess.move(currentMove);
+            const m = capturingMoves[i];
+            const fen = chess.fen();
+            if (this.pieceIsTrapped(fen, m)) {
+                if (m.captured && _utils_1.PIECE_VALUES[m.piece] < _utils_1.PIECE_VALUES[m.captured]) {
+                    return {
+                        trappedPiece: m.captured,
+                        trappingSquares: chess
+                            .moves({ square: m.to, verbose: true })
+                            .map((s) => s.to)
+                            .concat(m.to),
+                    };
+                }
+                else {
+                    // piece doesn't move. can we capture it?
+                    const chessCopy = new chess_js_1.Chess(chess.fen());
+                    (0, _utils_1.invertTurn)(chessCopy);
+                    if ((0, _utils_1.attackingSquareIsGood)(chessCopy.fen(), m.to)) {
+                        return {
+                            trappedPiece: m.captured,
+                            trappingSquares: chess
+                                .moves({ square: m.to, verbose: true })
+                                .map((s) => s.to)
+                                .concat(m.to),
+                        };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    pieceIsTrapped(position, move) {
+        const attackingSquare = move.from;
+        const threatenedSquare = move.to;
+        const escapeSquares = (0, _utils_1.getEscapeSquares)(position, threatenedSquare);
+        const blockingMoves = (0, _utils_1.getBlockingMoves)(position, attackingSquare, threatenedSquare);
+        // can't trap a pawn, any pinned piece should not be a 'trap'
+        if (move.captured === "p" || this.piecePinnedToKing(position, move.to))
+            return false;
+        return escapeSquares.length === 0 && blockingMoves.length === 0;
+    }
+    getCapturablePieces(currentMove, position) {
+        // A capturable piece is one that can be taken. No other assumptions
+        // game must be the initial position
+        const chessCopy = new chess_js_1.Chess(position);
+        chessCopy.move(currentMove);
+        (0, _utils_1.invertTurn)(chessCopy);
+        const possibleMoves = chessCopy.moves({ verbose: true });
+        let targetedPieces = [];
+        for (const m of possibleMoves) {
+            if (m.captured) {
+                targetedPieces.push(m);
+            }
+        }
+        return targetedPieces;
+    }
+    piecePinnedToKing(fen, square) {
+        const chess = new chess_js_1.Chess(fen);
+        const color = chess.get(square)?.color;
+        const parts = fen.split(" ");
+        fen = parts[0] + " " + color + " " + parts.slice(2).join(" ");
+        chess.load(fen, { skipValidation: true });
+        if (chess.inCheck()) {
+            return false;
+        }
+        chess.remove(square);
+        return chess.inCheck();
+    }
+}
+exports.TrapTactics = TrapTactics;

package/dist/tactics/index.d.ts

@@ -0,0 +1,7 @@
+export { BaseTactic } from "./BaseTactic";
+export { ForkTactics } from "./Fork";
+export { HangingPieceTactics } from "./HangingPiece";
+export { PinTactics } from "./Pin";
+export { SacrificeTactics } from "./Sacrifice";
+export { SkewerTactics } from "./Skewer";
+export { TrapTactics } from "./Trap";

package/dist/tactics/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrapTactics = exports.SkewerTactics = exports.SacrificeTactics = exports.PinTactics = exports.HangingPieceTactics = exports.ForkTactics = exports.BaseTactic = void 0;
+var BaseTactic_1 = require("./BaseTactic");
+Object.defineProperty(exports, "BaseTactic", { enumerable: true, get: function () { return BaseTactic_1.BaseTactic; } });
+var Fork_1 = require("./Fork");
+Object.defineProperty(exports, "ForkTactics", { enumerable: true, get: function () { return Fork_1.ForkTactics; } });
+var HangingPiece_1 = require("./HangingPiece");
+Object.defineProperty(exports, "HangingPieceTactics", { enumerable: true, get: function () { return HangingPiece_1.HangingPieceTactics; } });
+var Pin_1 = require("./Pin");
+Object.defineProperty(exports, "PinTactics", { enumerable: true, get: function () { return Pin_1.PinTactics; } });
+var Sacrifice_1 = require("./Sacrifice");
+Object.defineProperty(exports, "SacrificeTactics", { enumerable: true, get: function () { return Sacrifice_1.SacrificeTactics; } });
+var Skewer_1 = require("./Skewer");
+Object.defineProperty(exports, "SkewerTactics", { enumerable: true, get: function () { return Skewer_1.SkewerTactics; } });
+var Trap_1 = require("./Trap");
+Object.defineProperty(exports, "TrapTactics", { enumerable: true, get: function () { return Trap_1.TrapTactics; } });

package/dist/types.d.ts

@@ -0,0 +1,46 @@
+import { Move, Piece, Square } from "chess.js";
+import { _TacticContext } from "./_types";
+export type Fen = string;
+export type TacticOptions = {
+    trimEndSequence?: boolean;
+};
+export type UciEvaluation = {
+    sequence: string | string[] | Move[];
+};
+export type MoveEvaluation = {
+    move: string | {
+        from: string;
+        to: string;
+    } | Move;
+    followup: string | string[] | Move[];
+};
+export type Evaluation = UciEvaluation | MoveEvaluation;
+export type DefaultTacticContext = {
+    position: Fen;
+    evaluation: Evaluation;
+};
+export type PositionComparisonTacticContext = DefaultTacticContext & {
+    prevEvaluation: Evaluation;
+    prevMove: Move;
+    prevPosition: Fen;
+};
+export type TacticContext = DefaultTacticContext | PositionComparisonTacticContext;
+export type TacticKey = "fork" | "pin" | "skewer" | "sacrifice" | "trap" | "hanging";
+export interface TacticClassifier {
+    findTactic(context: _TacticContext): Tactic | null;
+    isTactic(context: _TacticContext): Partial<Tactic> | null;
+}
+export type SequenceInterpretation = {
+    sequence: Move[];
+    startPosition: Fen;
+    endPosition: Fen;
+    materialChange: number;
+};
+export type Tactic = SequenceInterpretation & {
+    type: TacticKey;
+    triggerIndex: number;
+    attackedPieces: {
+        square: Square;
+        piece: Piece;
+    }[];
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/SequenceInterpreter.d.ts

@@ -0,0 +1,13 @@
+import { Fen, SequenceInterpretation } from "../types";
+import { Move, Square } from "chess.js";
+import { _TacticContext } from "src/_types";
+export declare class SequenceInterpreter {
+    private evaluation;
+    private position;
+    setContext(context: _TacticContext): void;
+    getCaptureSequence(position: Fen, sequence: Move[]): any[];
+    identifyWinningSequence(attackerSquares: Square[], attackedSquares: Square[]): SequenceInterpretation | null;
+    private capturedAttackedPieces;
+    private isDesparado;
+    positionAfterSequence(position: Fen, sequence: string[] | Move[] | null): string;
+}

package/dist/utils/SequenceInterpreter.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequenceInterpreter = void 0;
+const chess_js_1 = require("chess.js");
+const _utils_1 = require("./index");
+class SequenceInterpreter {
+    evaluation;
+    position;
+    setContext(context) {
+        const { evaluation, position } = context;
+        this.evaluation = evaluation;
+        this.position = position;
+    }
+    getCaptureSequence(position, sequence) {
+        const chess = new chess_js_1.Chess(position);
+        const matches = [];
+        for (const s of sequence) {
+            const prevChess = new chess_js_1.Chess(chess.fen());
+            const m = chess.move(s);
+            if (m.captured || chess.inCheck() || prevChess.inCheck()) {
+                matches.push(m.san);
+            }
+            else {
+                break;
+            }
+        }
+        return matches;
+    }
+    // either the pieces on attackedSquares are captured for material gain
+    // or defender desparados on attackerSquare for a loss of material
+    // the separation of tacticalSequence and remainingSequence
+    // is to ensure that non-capturing engine intermezzos
+    // still allow captures on attackedSquares to be found
+    identifyWinningSequence(attackerSquares, attackedSquares) {
+        if (attackedSquares.length === 0 || attackerSquares.length === 0)
+            return null;
+        let tacticalSequence = [];
+        const chess = new chess_js_1.Chess(this.position);
+        const moves = this.evaluation.sequence;
+        for (let i = 0; i < moves.length; i++) {
+            const move = moves[i];
+            tacticalSequence.push(move);
+            const position = chess.fen();
+            chess.move(move);
+            if (this.capturedAttackedPieces(move, attackerSquares, attackedSquares) ||
+                this.isDesparado(position, move)) {
+                const remainingSequence = moves.slice(i + 1);
+                tacticalSequence = tacticalSequence.concat(this.getCaptureSequence(chess.fen(), remainingSequence));
+                const endPosition = this.positionAfterSequence(this.position, tacticalSequence);
+                const materialChange = (0, _utils_1.getMaterialChange)(position, endPosition, (0, _utils_1.colorToPlay)(this.position));
+                if (materialChange > 0) {
+                    return {
+                        startPosition: this.position,
+                        endPosition: endPosition,
+                        sequence: tacticalSequence,
+                        materialChange: materialChange,
+                    };
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+    capturedAttackedPieces(move, attackerSquares, attackedSquares) {
+        const capturedSquares = attackedSquares.filter((s) => {
+            // move came from an attacker square, to an attackedSquare, and captured a piece
+            return s === move.to && move.captured;
+        });
+        return capturedSquares.length > 0;
+    }
+    isDesparado(position, move) {
+        if (!move.captured)
+            return false;
+        return (0, _utils_1.attackingSquareIsBad)(position, move.to);
+    }
+    positionAfterSequence(position, sequence) {
+        if (!sequence)
+            return position;
+        const chess = new chess_js_1.Chess(position);
+        sequence.forEach((m) => {
+            chess.move(m);
+        });
+        return chess.fen();
+    }
+}
+exports.SequenceInterpreter = SequenceInterpreter;

package/dist/utils/TacticContextParser.d.ts

@@ -0,0 +1,9 @@
+import { Evaluation, Fen, MoveEvaluation, TacticContext, TacticOptions, UciEvaluation } from "../types";
+import { _Evaluation, _TacticContext } from "src/_types";
+export declare class TacticContextParser {
+    static parse(context: TacticContext, options: TacticOptions): _TacticContext;
+    static parseEvaluation(position: Fen, evaluation: Evaluation, options: TacticOptions): _Evaluation;
+    private static trimEndCaptures;
+    static parseMoveEvaluation(position: Fen, evaluation: MoveEvaluation): _Evaluation;
+    static parseUciEvaluation(position: Fen, evaluation: UciEvaluation): _Evaluation;
+}

package/dist/utils/TacticContextParser.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TacticContextParser = void 0;
+const chess_js_1 = require("chess.js");
+const _chess_tactics_1 = require("..");
+class TacticContextParser {
+    static parse(context, options) {
+        const evaluation = this.parseEvaluation(context.position, context.evaluation, options);
+        if ("prevEvaluation" in context) {
+            const prevEvaluation = this.parseEvaluation(context.prevPosition, context.prevEvaluation, options);
+            return {
+                evaluation: evaluation,
+                position: context.position,
+                prevEvaluation: prevEvaluation,
+                prevMove: context.prevMove,
+                prevPosition: context.prevPosition,
+            };
+        }
+        return {
+            evaluation: evaluation,
+            position: context.position,
+        };
+    }
+    static parseEvaluation(position, evaluation, options) {
+        let parsedEvaluation;
+        if ("sequence" in evaluation) {
+            parsedEvaluation = this.parseUciEvaluation(position, evaluation);
+        }
+        else {
+            parsedEvaluation = this.parseMoveEvaluation(position, evaluation);
+        }
+        if (options.trimEndSequence) {
+            parsedEvaluation.sequence = this.trimEndCaptures(parsedEvaluation.sequence);
+        }
+        return parsedEvaluation;
+    }
+    static trimEndCaptures(moveList) {
+        let i = moveList.length - 1;
+        while (i >= 0) {
+            if (moveList[i].captured) {
+                i -= 1;
+            }
+            else {
+                break;
+            }
+        }
+        return moveList.slice(0, i + 1);
+    }
+    static parseMoveEvaluation(position, evaluation) {
+        let chess;
+        try {
+            chess = new chess_js_1.Chess(position);
+        }
+        catch (error) {
+            throw new _chess_tactics_1.ChessTacticsParserError(`Invalid position argument: ${position}`, "INVALID_FEN", { cause: error });
+        }
+        const sequence = Array.isArray(evaluation.followup)
+            ? evaluation.followup
+            : evaluation.followup.split(/\s+/).filter((m) => m);
+        let firstMove;
+        try {
+            firstMove = chess.move(evaluation.move);
+        }
+        catch (error) {
+            throw new _chess_tactics_1.ChessTacticsParserError(`Invalid move: ${JSON.stringify(evaluation.move)} is not playable in ${position}`, "INVALID_MOVE", { cause: error });
+        }
+        const moveList = [firstMove];
+        let currPos;
+        sequence.forEach((s) => {
+            try {
+                currPos = chess.fen();
+                moveList.push(chess.move(s));
+            }
+            catch (error) {
+                throw new _chess_tactics_1.ChessTacticsParserError(`Invalid followup: ${JSON.stringify(s)} is not playable in ${currPos}`, "INVALID_FOLLOWUP", { cause: error });
+            }
+        });
+        return {
+            sequence: moveList,
+        };
+    }
+    static parseUciEvaluation(position, evaluation) {
+        let chess;
+        try {
+            chess = new chess_js_1.Chess(position);
+        }
+        catch (error) {
+            throw new _chess_tactics_1.ChessTacticsParserError(`Invalid position argument: ${position}`, "INVALID_FEN", { cause: error });
+        }
+        const moveList = [];
+        const sequence = Array.isArray(evaluation.sequence)
+            ? evaluation.sequence
+            : evaluation.sequence.split(/\s+/).filter((m) => m);
+        let currPos;
+        sequence.forEach((s) => {
+            try {
+                currPos = chess.fen();
+                moveList.push(chess.move(s));
+            }
+            catch (error) {
+                throw new _chess_tactics_1.ChessTacticsParserError(`Invalid sequence: ${JSON.stringify(s)} is not playable in ${currPos}`, "INVALID_SEQUENCE", { cause: error });
+            }
+        });
+        return {
+            sequence: moveList,
+        };
+    }
+}
+exports.TacticContextParser = TacticContextParser;

package/dist/utils/TacticHeuristics.d.ts

@@ -0,0 +1,9 @@
+import { Fen } from "../types";
+import { Move, Square } from "chess.js";
+export declare function attackingSquareIsGood(fen: Fen, square: Square, startingMove?: Move): boolean;
+export declare function attackingSquareIsBad(fen: Fen, square: Square, startingMove?: Move): boolean;
+export declare function materialAdvantageAfterTradesAtSquare(position: Fen, square: Square, startingMove?: Move): number;
+export declare function getEscapeSquares(fen: Fen, square: Square): any[];
+export declare function getBlockingMoves(fen: Fen, attackingSquare: Square, threatenedSquare: Square): any[];
+export declare function getMovesToSquare(fen: Fen, square: Square): Move[];
+export declare function getThreateningMoves(position: Fen, currentMove: Move): Move[];