chess-tactics 0.0.12 → 0.0.13

package/README.md

@@ -1,6 +1,6 @@
 # chess-tactics
 
-chess-tactics is a tactic detection library that returns verbose tactic descriptions given a position and an engine move continuation.
+chess-tactics is an opinionated tactic detection library that finds a tactic, the pieces involved, and the tactical sequence given a position and its engine evaluation.
 
 Supported Tactics:
 
@@ -37,7 +37,6 @@ const tactics = chessTactics.classify(context); // [{type:"fork", ... }]
 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`.
 
 ---
 
@@ -46,8 +45,8 @@ Creates a new instance of the tactics classifier.
 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).
+-   **`options`** [`TacticOptions`](#tactic-options): An object to modify class behavior
+-   **Returns**: [`Tactic[]`](#tactic). An array of tactics found in the position
 
 ---
 
@@ -61,7 +60,7 @@ Supported tactical patterns:
 
 ### `TacticContext`
 
-Context required for the tactic algorithms. Provide the type that supports all patterns passed to constructor
+Context required for the tactic algorithms
 
 | Type                              | Supported Tactic Keys                                   | Description                                                           |
 | :-------------------------------- | :------------------------------------------------------ | :-------------------------------------------------------------------- |
@@ -85,6 +84,17 @@ Context required for the tactic algorithms. Provide the type that supports all p
 
 ---
 
+### `TacticOptions`
+
+Options to modify behavior
+
+<a id="tactic-options"></a>
+
+| Type                | Type                       | Description                                                                                                                                                                                                                                                                                                                  |
+| :------------------ | :------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `trimEndSequence`   | `boolean` (default:`True`) | Preprocessing step that if true, trims the end of the evaluation sequence while it contains captures or checks. If you are providing a raw engine string, this should be True to avoid miscalculation of sequence material change. (Ex. Set to false if you provide puzzle evaluations that end at the puzzle's completion). |
+| `maxLookaheadMoves` | `number` (default: 5)      | Specifies the maximum number of half-moves (ply) that can contain checks or captures before the tactical move is played. (Ex. If set to zero, a trade preceeding a fork will not be found because the first move is not a forking move)                                                                                      |
+
 ### `Evaluation`
 
 <a id="evaluation"></a>

package/dist/tactics/BaseTactic.js

@@ -19,6 +19,8 @@ class BaseTactic {
             this.sequenceInterpreter.setContext(newContext);
             const tactic = this.isTactic(newContext);
             if (tactic) {
+                // TODO
+                // Why the hardcode? Could we find even some subset of behavior that allows for "two attackers vs one defender" free pieces?
                 if (tactic.type === "hanging" && i > 0) {
                     return null;
                 }

package/dist/tactics/Fork.js

@@ -10,7 +10,10 @@ class ForkTactics extends _tactics_1.BaseTactic {
         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);
+        let attackedSquares = cosmeticForks.map((m) => m.to);
+        attackedSquares = (0, _utils_1.filterOutInitiallyAttackedSquares)(position, currentMove, attackedSquares);
+        if (attackedSquares.length < 2)
+            return null;
         const tacticalSequence = this.sequenceInterpreter.identifyWinningSequence([currentMove.to], attackedSquares);
         if (tacticalSequence) {
             return {

package/dist/tactics/Pin.js

@@ -9,8 +9,14 @@ class PinTactics extends _tactics_1.BaseTactic {
         const { position, evaluation } = context;
         const chess = new chess_js_1.Chess(position);
         const currentMove = evaluation.sequence[0];
-        const cosmeticPins = this.getCosmeticPins(position, currentMove);
+        let cosmeticPins = this.getCosmeticPins(position, currentMove);
         for (const [nextMoveWithPiece, nextMoveWithoutPiece] of cosmeticPins) {
+            if ((0, _utils_1.filterOutInitiallyAttackedSquares)(position, currentMove, [
+                nextMoveWithPiece.to,
+                nextMoveWithoutPiece.to,
+            ]).length < 2) {
+                continue;
+            }
             const tacticalSequence = this.sequenceInterpreter.identifyWinningSequence([currentMove.to], [nextMoveWithPiece.to, nextMoveWithoutPiece.to]);
             if (tacticalSequence) {
                 return {

package/dist/tactics/Skewer.js

@@ -11,6 +11,12 @@ class SkewerTactics extends _tactics_1.BaseTactic {
         const currentMove = chess.move(evaluation.sequence[0]);
         const cosmeticSkewers = this.getCosmeticSkewers(context);
         for (const [nextMoveWithPiece, nextMoveWithoutPiece] of cosmeticSkewers) {
+            if ((0, _utils_1.filterOutInitiallyAttackedSquares)(position, currentMove, [
+                nextMoveWithPiece.to,
+                nextMoveWithoutPiece.to,
+            ]).length < 2) {
+                continue;
+            }
             const tacticalSequence = this.sequenceInterpreter.identifyWinningSequence([currentMove.to], [nextMoveWithPiece.to, nextMoveWithoutPiece.to]);
             if (tacticalSequence) {
                 return {

package/dist/tactics/Trap.js

@@ -36,7 +36,10 @@ class TrapTactics extends _tactics_1.BaseTactic {
             chess.move(currentMove);
             const m = capturingMoves[i];
             const fen = chess.fen();
+            // There are cases where previously trapped pieces are classified on the next move.
+            // The current move should reveal or directly attack the piece of interest
             // TODO
+            // Add testcases where piece is trapped, and moving away from an opponent's one check threat triggers the 'trap' on the unrelated piece
             if (this.pieceIsTrapped(fen, m)) {
                 if (m.captured && _utils_1.PIECE_VALUES[m.piece] < _utils_1.PIECE_VALUES[m.captured]) {
                     return {

package/dist/utils/SequenceInterpreter.js

@@ -26,11 +26,10 @@ class SequenceInterpreter {
         }
         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
+    // Tactic is returned if the pieces on attackerSquares capture any of the pieces on attackedSquares
+    // AND the resulting position after checks and captures won material
+    // TODO
+    // The isDesparado case handles 6 of 170 tests. It's probably too broad, try only desparados
     identifyWinningSequence(attackerSquares, attackedSquares) {
         if (attackedSquares.length === 0 || attackerSquares.length === 0)
             return null;
@@ -60,6 +59,11 @@ class SequenceInterpreter {
                     return null;
                 }
             }
+            // Track the attackers movements through the sequence
+            const attackerIdx = attackerSquares.indexOf(move.from);
+            if (attackerIdx !== -1) {
+                attackerSquares[attackerIdx] = move.to;
+            }
         }
         return null;
     }

package/dist/utils/TacticHeuristics.d.ts

@@ -7,3 +7,4 @@ 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[];
+export declare function filterOutInitiallyAttackedSquares(position: Fen, currentMove: Move, attackedSquares: Square[]): Square[];

package/dist/utils/TacticHeuristics.js

@@ -7,6 +7,7 @@ exports.getEscapeSquares = getEscapeSquares;
 exports.getBlockingMoves = getBlockingMoves;
 exports.getMovesToSquare = getMovesToSquare;
 exports.getThreateningMoves = getThreateningMoves;
+exports.filterOutInitiallyAttackedSquares = filterOutInitiallyAttackedSquares;
 const chess_js_1 = require("chess.js");
 const _utils_1 = require("./index");
 function attackingSquareIsGood(fen, square, startingMove = null) {
@@ -163,7 +164,8 @@ function getThreateningMoves(position, currentMove) {
     const threateningMoves = [];
     for (const m of possibleMoves) {
         for (const n of possibleMoves) {
-            if (n.captured !== "k" && n.to !== m.to)
+            // we remove the pieces to avoid the scenario where one of the forked pieces 'defends' the other through the attacking piece and nullifies the tactic
+            if (n.captured !== "k" && n.captured !== "p" && n.to !== m.to)
                 chess.remove(n.to);
         }
         if (m.captured && attackingSquareIsGood(chess.fen(), m.to, m) && m.captured !== m.piece) {
@@ -175,3 +177,10 @@ function getThreateningMoves(position, currentMove) {
     }
     return threateningMoves;
 }
+function filterOutInitiallyAttackedSquares(position, currentMove, attackedSquares) {
+    const chess = new chess_js_1.Chess(position);
+    const attackingPieceInitialMoves = chess
+        .moves({ square: currentMove.from, verbose: true })
+        .map((m) => m.to);
+    return attackedSquares.filter((s) => !attackingPieceInitialMoves.includes(s));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "chess-tactics",
-    "version": "0.0.12",
+    "version": "0.0.13",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/antonryoung02/chess-tactics.git"