chess-tactics 0.0.1

package/README.md

@@ -0,0 +1,145 @@
+# chess-tactics
+
+chess-tactics is a tactic detection library that returns verbose tactic descriptions given a position and an engine move continuation.
+
+Supported Tactics:
+
+-   Fork
+-   Pin
+-   Skewer
+-   Sacrifice
+-   Trapped Piece
+-   Hanging Piece
+
+## Installation
+
+(npm release in progress)
+
+## Example Usage
+
+```typescript
+const chessTactics = new ChessTactics(["fork", "pin", "skewer", "trap"]);
+const context = {
+    position: "8/4r1k1/8/8/8/2PPN3/1PK5/8 w - - 0 1",
+    evaluation: {
+        sequence: "e3f5 g7f6 f5e7 f6e6 c2b3 e6d6 b3c4",
+    },
+};
+const tactics = chessTactics.classify(context); // [{type:"fork", ... }]
+```
+
+## API Reference
+
+### `ChessTactics`
+
+#### `constructor(tacticKeys?:` [`TacticKey[]`](#tactickey) `)`
+
+Creates a new instance of the tactics classifier.
+
+-   **`tacticKeys`** (optional): An array of which tactics to include. Defaults to all available tactics
+-   **Returns**: An instance of `ChessTactics`.
+
+---
+
+#### `.classify(context:TacticContext, options:TacticOptions?)`
+
+Analyzes a board position and the sequence of moves to determine if a specific tactic has occurred.
+
+-   **`context`** (TacticContext): An object containing the position & evaluation
+-   **`options`** (TacticOptions): An object to set class behavior
+-   **Returns**: [`Tactic[]`](#tactic).
+
+---
+
+## Type Definitions
+
+### `TacticKey`
+
+<a id="tactickey"></a>
+Supported tactical patterns:
+`"fork"` | `"pin"` | `"skewer"` | `"sacrifice"` | `"trap"` | `"hanging"`
+
+### `TacticContext`
+
+Context required for the tactic algorithms. Provide the type that supports all patterns passed to constructor
+
+| Type                              | Supported Tactic Keys                                   | Description                                                           |
+| :-------------------------------- | :------------------------------------------------------ | :-------------------------------------------------------------------- |
+| `DefaultTacticContext`            | `fork`, `pin`, `skewer`, `trap`, `sacrifice`            | Standard analysis requiring only the current position and evaluation. |
+| `PositionComparisonTacticContext` | `hanging`, `fork`, `pin`, `skewer`, `trap`, `sacrifice` | For tactics that require knowledge of the previous move's state       |
+
+---
+
+#### `DefaultTacticContext`
+
+-   **`position`**: `Fen` (String)
+-   **`evaluation`**: [`Evaluation`](#evaluation)
+
+#### `PositionComparisonTacticContext`
+
+-   **`position`**: `Fen` (String)
+-   **`evaluation`**: [`Evaluation`](#evaluation)
+-   **`prevPosition`**: `Fen`
+-   **`prevEvaluation`**: [`Evaluation`](#evaluation)
+-   **`prevMove`**: `Move`
+
+---
+
+### `Evaluation`
+
+<a id="evaluation"></a>
+
+The engine evaluation of a position, separated into a type union for convenience
+
+| Type             | Description                                                                                              |
+| :--------------- | :------------------------------------------------------------------------------------------------------- |
+| `UciEvaluation`  | Sequence containing the best line in a position                                                          |
+| `MoveEvaluation` | Sequence containing the best line in a position where the first move and followup sequence are separated |
+
+---
+
+#### `UciEvaluation`
+
+-   **`sequence`**: `string` | `string[]` | [`Move[]`](#external-types-chessjs)
+    -   The evaluation sequence
+
+#### `MoveEvaluation`
+
+-   **`move`**: `string` | `{ from: string; to: string }` | `Move`
+    -   The first move in the evaluation sequence.
+-   **`followup`**: `string` | `string[]` | [`Move[]`](#external-types-chessjs)
+    -   The expected sequence of moves following the initial move.
+
+---
+
+### `Tactic`
+
+<a id="tactic"></a>
+The final object returned by the classification engine. It contains the identified tactical theme along with the board state changes.
+
+| Property         | Type                                                        | Description                                                             |
+| :--------------- | :---------------------------------------------------------- | :---------------------------------------------------------------------- |
+| `type`           | [`TacticKey`](#tactickey)                                   | The category of tactic (e.g., fork, pin).                               |
+| `attackedPieces` | [`{piece:Piece, square:Square}[]`](#external-types-chessjs) | The pieces involved on the recieving end of the tactic                  |
+| `sequence`       | [`Move[]`](#external-types-chessjs)                         | The array of moves consisting of the entire tactical sequence.          |
+| `triggerIndex`   | `number`                                                    | The `sequence` index of the tactical move                               |
+| `startPosition`  | `Fen`                                                       | The FEN string of the position before the sequence.                     |
+| `endPosition`    | `Fen`                                                       | The FEN string of the position after the sequence.                      |
+| `materialChange` | `number`                                                    | The net material gain for the player of the tactic (e.g., `3` or `-5`). |
+
+---
+
+### External Types (chess.js)
+
+<a id="chessjs-types"></a>
+This library accepts and returns types from [chess.js](https://github.com/jhlywa/chess.js) for board representation:
+
+**`Square`**: A string representing a square on the board (e.g., `'a1'`, `'h8'`).
+
+**`Piece`**: `{ type: 'p' | 'n' | 'b' | 'r' | 'q' | 'k', color: 'w' | 'b' }`.
+
+**`Move`**: A move object containing `from`, `to`, `promotion`, and `san`
+
+### Dependencies
+
+`chess.js: ^1.4.0`

package/dist/ChessTactics.d.ts

@@ -0,0 +1,8 @@
+import { Tactic, TacticContext, TacticKey, TacticOptions } from "./types";
+export declare class ChessTactics {
+    private tacticClassifiers;
+    private selectedTactics;
+    constructor(tacticKeys?: TacticKey[]);
+    private initializeClassifiers;
+    classify(context: TacticContext, options?: TacticOptions): Tactic[];
+}

package/dist/ChessTactics.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChessTactics = void 0;
+const TacticFactory_1 = require("./TacticFactory");
+const TacticContextParser_1 = require("./utils/TacticContextParser");
+const _utils_1 = require("./utils/index");
+class ChessTactics {
+    tacticClassifiers;
+    selectedTactics;
+    constructor(tacticKeys = []) {
+        this.selectedTactics = tacticKeys;
+        this.initializeClassifiers();
+    }
+    initializeClassifiers() {
+        if (this.selectedTactics.length === 0) {
+            this.selectedTactics = _utils_1.DEFAULT_TACTIC_CLASSIFIERS;
+        }
+        else {
+            this.tacticClassifiers = [];
+            for (const t of this.selectedTactics) {
+                this.tacticClassifiers.push(TacticFactory_1.TacticFactory.create(t));
+            }
+        }
+    }
+    classify(context, options = _utils_1.DEFAULT_TACTIC_OPTIONS) {
+        const tactics = [];
+        const mergedOptions = { ..._utils_1.DEFAULT_TACTIC_OPTIONS, ...options };
+        const internalContext = TacticContextParser_1.TacticContextParser.parse(context, mergedOptions);
+        for (const classifier of this.tacticClassifiers) {
+            const t = classifier.findTactic(internalContext);
+            if (t)
+                tactics.push(t);
+        }
+        return tactics;
+    }
+}
+exports.ChessTactics = ChessTactics;

package/dist/TacticFactory.d.ts

@@ -0,0 +1,4 @@
+import { TacticClassifier, TacticKey } from "./types";
+export declare class TacticFactory {
+    static create(type: TacticKey): TacticClassifier;
+}

package/dist/TacticFactory.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TacticFactory = void 0;
+const _tactics_1 = require("./tactics/index");
+const _utils_1 = require("./utils/index");
+class TacticFactory {
+    static create(type) {
+        const sequenceInterpreter = new _utils_1.SequenceInterpreter();
+        switch (type) {
+            case "fork":
+                return new _tactics_1.ForkTactics(sequenceInterpreter);
+            case "pin":
+                return new _tactics_1.PinTactics(sequenceInterpreter);
+            case "skewer":
+                return new _tactics_1.SkewerTactics(sequenceInterpreter);
+            case "sacrifice":
+                return new _tactics_1.SacrificeTactics(sequenceInterpreter);
+            case "trap":
+                return new _tactics_1.TrapTactics(sequenceInterpreter);
+            case "hanging":
+                return new _tactics_1.HangingPieceTactics(sequenceInterpreter);
+        }
+    }
+}
+exports.TacticFactory = TacticFactory;

package/dist/_types.d.ts

@@ -0,0 +1,15 @@
+import { Move } from "chess.js";
+import { Fen } from "./types";
+export type _Evaluation = {
+    sequence: Move[];
+};
+export type _DefaultTacticContext = {
+    position: Fen;
+    evaluation: _Evaluation;
+};
+export type _PositionComparisonTacticContext = _DefaultTacticContext & {
+    prevEvaluation: _Evaluation;
+    prevPosition: Fen;
+    prevMove: Move;
+};
+export type _TacticContext = _DefaultTacticContext | _PositionComparisonTacticContext;

package/dist/_types.js

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

package/dist/errors.d.ts

@@ -0,0 +1,7 @@
+export type ChessTacticParserErrorCode = "INVALID_FEN" | "INVALID_MOVE" | "INVALID_FOLLOWUP" | "INVALID_SEQUENCE";
+export declare class ChessTacticsParserError extends Error {
+    code: ChessTacticParserErrorCode;
+    constructor(message: string, code: ChessTacticParserErrorCode, options?: {
+        cause?: unknown;
+    });
+}

package/dist/errors.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChessTacticsParserError = void 0;
+class ChessTacticsParserError extends Error {
+    code;
+    constructor(message, code, options) {
+        super(message, options);
+        this.name = "ChessTacticsParserError";
+        this.code = code;
+    }
+}
+exports.ChessTacticsParserError = ChessTacticsParserError;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export { ChessTactics } from "./ChessTactics";
+export { TacticFactory } from "./TacticFactory";
+export * from "./errors";

package/dist/index.js

@@ -0,0 +1,23 @@
+"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.TacticFactory = exports.ChessTactics = void 0;
+__exportStar(require("./types"), exports);
+var ChessTactics_1 = require("./ChessTactics");
+Object.defineProperty(exports, "ChessTactics", { enumerable: true, get: function () { return ChessTactics_1.ChessTactics; } });
+var TacticFactory_1 = require("./TacticFactory");
+Object.defineProperty(exports, "TacticFactory", { enumerable: true, get: function () { return TacticFactory_1.TacticFactory; } });
+__exportStar(require("./errors"), exports);

package/dist/tactics/BaseTactic.d.ts

@@ -0,0 +1,13 @@
+import { Tactic, TacticClassifier } from "../types";
+import { SequenceInterpreter } from "../utils/index";
+import { _TacticContext } from "src/_types";
+import { Move } from "chess.js";
+export declare class BaseTactic implements TacticClassifier {
+    protected sequenceInterpreter: SequenceInterpreter;
+    constructor(sequenceInterpreter: SequenceInterpreter);
+    findTactic(context: _TacticContext): Tactic | null;
+    isTactic(context: _TacticContext): Partial<Tactic> | null;
+    wrapTactic(tactic: Partial<Tactic>, context: _TacticContext, sequence: Move[], sequenceIndex: number): Tactic;
+    private isForcingPosition;
+    private contextAtState;
+}

package/dist/tactics/BaseTactic.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTactic = void 0;
+const _utils_1 = require("../utils/index");
+const chess_js_1 = require("chess.js");
+class BaseTactic {
+    sequenceInterpreter;
+    constructor(sequenceInterpreter) {
+        this.sequenceInterpreter = sequenceInterpreter;
+    }
+    // Detects non-immediate tactics by iteratively calling isTactic on the position as long as the previous attacker move was 'forcing'
+    findTactic(context) {
+        let sequence = context.evaluation.sequence;
+        const chess = new chess_js_1.Chess(context.position);
+        let isForcing = true;
+        let i = 0;
+        while (isForcing && i < sequence.length - 2) {
+            const newContext = this.contextAtState(context, chess.fen(), sequence, i);
+            this.sequenceInterpreter.setContext(newContext);
+            const tactic = this.isTactic(newContext);
+            if (tactic) {
+                return this.wrapTactic(tactic, context, sequence, i);
+            }
+            // Play your move and opponent's response
+            const currMove = chess.move(sequence[i]);
+            isForcing = this.isForcingPosition(chess, currMove);
+            chess.move(sequence[i + 1]);
+            i += 2;
+        }
+        return null;
+    }
+    isTactic(context) {
+        throw new Error("BaseTactic.isTactic must be overridden in subclass");
+    }
+    wrapTactic(tactic, context, sequence, sequenceIndex) {
+        return {
+            type: tactic.type,
+            endPosition: tactic.endPosition,
+            attackedPieces: tactic.attackedPieces,
+            startPosition: context.position,
+            materialChange: (0, _utils_1.getMaterialChange)(context.position, tactic.endPosition, (0, _utils_1.colorToPlay)(context.position)),
+            triggerIndex: sequenceIndex,
+            sequence: sequence.slice(0, sequenceIndex).concat(tactic.sequence),
+        };
+    }
+    // could try adding 'madeThreat' to the isForcing if needed
+    // most likely would require a multipv > 1 engine evaluation for anything better than this
+    isForcingPosition(chess, move) {
+        return move.captured !== undefined || chess.inCheck();
+    }
+    contextAtState(context, position, sequence, sequenceIndex) {
+        let newContext = {
+            ...context,
+            position: position,
+            evaluation: { sequence: sequence.slice(sequenceIndex) },
+        };
+        if ("prevEvaluation" in context && sequenceIndex > 0) {
+            newContext = {
+                ...newContext,
+                prevPosition: context.position,
+                prevMove: sequence[sequenceIndex - 1],
+                prevEvaluation: context.evaluation,
+            };
+        }
+        return newContext;
+    }
+}
+exports.BaseTactic = BaseTactic;

package/dist/tactics/Fork.d.ts

@@ -0,0 +1,9 @@
+import { Move } from "chess.js";
+import { Fen, Tactic } from "../types";
+import { BaseTactic } from "./index";
+import { _DefaultTacticContext } from "src/_types";
+declare class ForkTactics extends BaseTactic {
+    isTactic(context: _DefaultTacticContext): Partial<Tactic> | null;
+    getCosmeticForks(position: Fen, currentMove: Move): Move[];
+}
+export { ForkTactics };

package/dist/tactics/Fork.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForkTactics = void 0;
+const chess_js_1 = require("chess.js");
+const _utils_1 = require("../utils/index");
+const _tactics_1 = require("./index");
+class ForkTactics 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 cosmeticForks = this.getCosmeticForks(position, currentMove);
+        const attackedSquares = cosmeticForks.map((m) => m.to);
+        const tacticalSequence = this.sequenceInterpreter.identifyWinningSequence([currentMove.to], attackedSquares);
+        if (tacticalSequence) {
+            return {
+                type: "fork",
+                attackedPieces: attackedSquares.map((s) => ({ square: s, piece: chess.get(s) })),
+                ...tacticalSequence,
+            };
+        }
+        return null;
+    }
+    getCosmeticForks(position, currentMove) {
+        const threateningMoves = (0, _utils_1.getThreateningMoves)(position, currentMove);
+        if (threateningMoves.length >= 2) {
+            return threateningMoves;
+        }
+        return [];
+    }
+}
+exports.ForkTactics = ForkTactics;

package/dist/tactics/HangingPiece.d.ts

@@ -0,0 +1,7 @@
+import { BaseTactic } from "./index";
+import { _PositionComparisonTacticContext } from "src/_types";
+import { Tactic } from "../types";
+declare class HangingPieceTactics extends BaseTactic {
+    isTactic(context: _PositionComparisonTacticContext): Partial<Tactic> | null;
+}
+export { HangingPieceTactics };

package/dist/tactics/HangingPiece.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HangingPieceTactics = void 0;
+const chess_js_1 = require("chess.js");
+const _utils_1 = require("../utils/index");
+const _tactics_1 = require("./index");
+class HangingPieceTactics extends _tactics_1.BaseTactic {
+    isTactic(context) {
+        const { position, evaluation, prevMove } = context;
+        const chess = new chess_js_1.Chess(position);
+        const currentMove = evaluation.sequence[0];
+        if (!currentMove.captured) {
+            return null;
+        }
+        if (prevMove.captured &&
+            _utils_1.PIECE_VALUES[prevMove.captured] >= _utils_1.PIECE_VALUES[currentMove.captured]) {
+            return null;
+        }
+        chess.load(position);
+        const attackers = chess.attackers(currentMove.to);
+        const tacticalSequence = this.sequenceInterpreter.identifyWinningSequence(attackers, [
+            currentMove.to,
+        ]);
+        if (tacticalSequence) {
+            return {
+                type: "hanging",
+                attackedPieces: [{ square: currentMove.to, piece: chess.get(currentMove.to) }],
+                ...tacticalSequence,
+            };
+        }
+        return null;
+    }
+}
+exports.HangingPieceTactics = HangingPieceTactics;

package/dist/tactics/Pin.d.ts

@@ -0,0 +1,10 @@
+import { Move } from "chess.js";
+import { BaseTactic } from "./index";
+import { _DefaultTacticContext } from "src/_types";
+import { Fen, Tactic } from "../types";
+declare class PinTactics extends BaseTactic {
+    isTactic(context: _DefaultTacticContext): Partial<Tactic> | null;
+    getCosmeticPins(position: Fen, currentMove: Move): Array<Array<Move>>;
+    movePreventsPawnMobility(position: Fen, currentMove: Move, moveCapturingPawn: Move, moveCapturingBehindPiece: Move): boolean;
+}
+export { PinTactics };

package/dist/tactics/Pin.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinTactics = void 0;
+const chess_js_1 = require("chess.js");
+const _utils_1 = require("../utils/index");
+const _tactics_1 = require("./index");
+class PinTactics extends _tactics_1.BaseTactic {
+    isTactic(context) {
+        const { position, evaluation } = context;
+        const chess = new chess_js_1.Chess(position);
+        const currentMove = evaluation.sequence[0];
+        const cosmeticPins = this.getCosmeticPins(position, currentMove);
+        for (const [nextMoveWithPiece, nextMoveWithoutPiece] of cosmeticPins) {
+            const tacticalSequence = this.sequenceInterpreter.identifyWinningSequence([currentMove.to], [nextMoveWithPiece.to, nextMoveWithoutPiece.to]);
+            if (tacticalSequence) {
+                return {
+                    type: "pin",
+                    attackedPieces: [
+                        { square: nextMoveWithPiece.to, piece: chess.get(nextMoveWithPiece.to) },
+                        {
+                            square: nextMoveWithoutPiece.to,
+                            piece: chess.get(nextMoveWithoutPiece.to),
+                        },
+                    ],
+                    ...tacticalSequence,
+                };
+            }
+        }
+        return null;
+    }
+    getCosmeticPins(position, currentMove) {
+        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 cosmeticPins = [];
+        for (const move of possibleNextMoves) {
+            // Can't pin a king or same piece
+            if (!move.captured || move.captured === "k" || move.captured === currentMove.piece) {
+                continue;
+            }
+            // Return to on next turn position and remove the piece
+            chess.load(position);
+            chess.move(currentMove);
+            chess.remove(move.to);
+            (0, _utils_1.invertTurn)(chess);
+            // Is a more valuable piece behind the capturable pieces
+            const possibleNextMovesWithoutPiece = chess.moves({
+                square: currentMove.to,
+                verbose: true,
+            });
+            const newMoves = (0, _utils_1.getMoveDiff)(possibleNextMoves, possibleNextMovesWithoutPiece);
+            // A cosmetic pin is 'did my piece move to a square that pins any lower value piece to a higher value piece'
+            for (const m of newMoves) {
+                if (m.captured && _utils_1.PIECE_VALUES[move.captured] < _utils_1.PIECE_VALUES[m.captured]) {
+                    if (move.captured === "p" &&
+                        !this.movePreventsPawnMobility(position, currentMove, move, m)) {
+                        continue;
+                    }
+                    cosmeticPins.push([move, m]); // [move to capture pinned piece, move to capture piece behind it]
+                }
+            }
+        }
+        return cosmeticPins;
+    }
+    movePreventsPawnMobility(position, currentMove, moveCapturingPawn, moveCapturingBehindPiece) {
+        // do any of the possible pawn movements uncover the pin -> losing material?
+        if (moveCapturingBehindPiece.captured === "k")
+            return true;
+        const pawnSquare = moveCapturingPawn.to;
+        const chess = new chess_js_1.Chess(position);
+        chess.move(currentMove);
+        const movesAfter = chess.moves({ square: pawnSquare, verbose: true });
+        // this case is mostly for king where the pawn movement is truly restricted
+        // this doesn't cover when currentMove blocks the pawn directly. commenting out
+        // now to see if the pawn move uncovers the pinned piece
+        let doesPrevent = false;
+        for (const move of movesAfter) {
+            chess.load(position);
+            chess.move(currentMove);
+            chess.move(move);
+            // the pawn can capture your pinning piece
+            if (move.to === currentMove.to) {
+                return false;
+            }
+            if (chess.attackers(moveCapturingBehindPiece.to).length > 0) {
+                doesPrevent = true;
+            }
+        }
+        return doesPrevent;
+    }
+}
+exports.PinTactics = PinTactics;

package/dist/tactics/Sacrifice.d.ts

@@ -0,0 +1,9 @@
+import { Move } from "chess.js";
+import { Fen, Tactic } from "../types";
+import { BaseTactic } from "./index";
+import { _DefaultTacticContext } from "src/_types";
+declare class SacrificeTactics extends BaseTactic {
+    isTactic(context: _DefaultTacticContext): Partial<Tactic> | null;
+    sacrificedMaterial(position: Fen, currentMove: Move): boolean;
+}
+export { SacrificeTactics };

package/dist/tactics/Sacrifice.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SacrificeTactics = void 0;
+const chess_js_1 = require("chess.js");
+const _utils_1 = require("../utils/index");
+const _tactics_1 = require("./index");
+class SacrificeTactics extends _tactics_1.BaseTactic {
+    isTactic(context) {
+        const { position, evaluation } = context;
+        const chess = new chess_js_1.Chess(position);
+        const currentMove = evaluation.sequence[0];
+        chess.move(currentMove);
+        const captureSequence = [currentMove].concat(this.sequenceInterpreter.getCaptureSequence(chess.fen(), evaluation.sequence.slice(1)));
+        chess.undo();
+        if (this.sacrificedMaterial(position, currentMove) && captureSequence.length > 0) {
+            const endPosition = this.sequenceInterpreter.positionAfterSequence(position, captureSequence);
+            const materialChange = (0, _utils_1.getMaterialChange)(position, endPosition, (0, _utils_1.colorToPlay)(position));
+            return {
+                type: "sacrifice",
+                attackedPieces: [{ square: currentMove.to, piece: chess.get(currentMove.to) }],
+                sequence: captureSequence,
+                startPosition: position,
+                endPosition: endPosition,
+                materialChange: materialChange,
+            };
+        }
+        return null;
+    }
+    sacrificedMaterial(position, currentMove) {
+        if (currentMove.promotion || currentMove.piece === "p") {
+            return false;
+        }
+        if ((0, _utils_1.attackingSquareIsBad)(position, currentMove.to, currentMove)) {
+            const materialGained = currentMove.captured ? _utils_1.PIECE_VALUES[currentMove.captured] : 0;
+            const materialLost = _utils_1.PIECE_VALUES[currentMove.piece];
+            return materialGained - materialLost < 0;
+        }
+        return false;
+    }
+}
+exports.SacrificeTactics = SacrificeTactics;

package/dist/tactics/Skewer.d.ts

@@ -0,0 +1,9 @@
+import { Move } from "chess.js";
+import { Tactic } from "../types";
+import { BaseTactic } from "./index";
+import { _DefaultTacticContext, _TacticContext } from "src/_types";
+declare class SkewerTactics extends BaseTactic {
+    isTactic(context: _DefaultTacticContext): Partial<Tactic> | null;
+    getCosmeticSkewers(context: _TacticContext): Move[][];
+}
+export { SkewerTactics };