chess-tactics 0.0.5 → 0.0.7

package/dist/TacticFactory.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TacticFactory = void 0;
 const _tactics_1 = require("./tactics/index");
 const _utils_1 = require("./utils/index");
+const SequenceInterpreter_1 = require("./utils/SequenceInterpreter");
 class TacticFactory {
     static create(type) {
         const sequenceInterpreter = new _utils_1.SequenceInterpreter();
@@ -16,7 +17,8 @@ class TacticFactory {
             case "sacrifice":
                 return new _tactics_1.SacrificeTactics(sequenceInterpreter);
             case "trap":
-                return new _tactics_1.TrapTactics(sequenceInterpreter);
+                const trapInterpreter = new SequenceInterpreter_1.TrapTacticsSequenceInterpreter();
+                return new _tactics_1.TrapTactics(trapInterpreter);
             case "hanging":
                 return new _tactics_1.HangingPieceTactics(sequenceInterpreter);
         }

package/dist/tactics/BaseTactic.js

@@ -14,11 +14,14 @@ class BaseTactic {
         const chess = new chess_js_1.Chess(context.position);
         let isForcing = true;
         let i = 0;
-        while (isForcing && i < sequence.length - 2) {
+        while (isForcing && i < Math.min(sequence.length - 2, 4)) {
             const newContext = this.contextAtState(context, chess.fen(), sequence, i);
             this.sequenceInterpreter.setContext(newContext);
             const tactic = this.isTactic(newContext);
             if (tactic) {
+                if (tactic.type === "hanging" && i > 0) {
+                    return null;
+                }
                 return this.wrapTactic(tactic, context, sequence, i);
             }
             // Play your move and opponent's response

package/dist/tactics/HangingPiece.js

@@ -6,14 +6,14 @@ 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 { position, evaluation, prevMove, prevPosition } = context;
+        const prevChess = new chess_js_1.Chess(prevPosition);
         const chess = new chess_js_1.Chess(position);
         const currentMove = evaluation.sequence[0];
-        if (!currentMove.captured) {
+        if (!currentMove.captured || currentMove.captured === "p") {
             return null;
         }
-        if (prevMove.captured &&
-            _utils_1.PIECE_VALUES[prevMove.captured] >= _utils_1.PIECE_VALUES[currentMove.captured]) {
+        if (prevChess.inCheck() || (prevMove.captured && prevMove.captured !== "p")) {
             return null;
         }
         chess.load(position);
@@ -21,7 +21,16 @@ class HangingPieceTactics extends _tactics_1.BaseTactic {
         const tacticalSequence = this.sequenceInterpreter.identifyWinningSequence(attackers, [
             currentMove.to,
         ]);
-        if (tacticalSequence) {
+        this.sequenceInterpreter.setContext({
+            evaluation: context.prevEvaluation,
+            position: context.prevPosition,
+        });
+        const prevSequence = this.sequenceInterpreter.identifyWinningSequence(attackers, [
+            currentMove.to,
+        ]);
+        if (tacticalSequence &&
+            tacticalSequence.materialChange >= _utils_1.PIECE_VALUES[currentMove.captured] &&
+            (!prevSequence || prevSequence.materialChange < _utils_1.PIECE_VALUES[currentMove.captured])) {
             return {
                 type: "hanging",
                 attackedPieces: [{ square: currentMove.to, piece: chess.get(currentMove.to) }],

package/dist/tactics/Trap.js

@@ -72,12 +72,16 @@ class TrapTactics extends _tactics_1.BaseTactic {
     getCapturablePieces(currentMove, position) {
         // A capturable piece is one that can be taken. No other assumptions
         // game must be the initial position
+        const chess = new chess_js_1.Chess(position);
+        const originalMoves = chess.moves({ verbose: true });
         const chessCopy = new chess_js_1.Chess(position);
         chessCopy.move(currentMove);
         (0, _utils_1.invertTurn)(chessCopy);
         const possibleMoves = chessCopy.moves({ verbose: true });
+        // moveDiff ensures the move you made is responsible for revealing the trap, either directly or indirectly
+        const moveDiff = (0, _utils_1.getMoveDiff)(originalMoves, possibleMoves);
         let targetedPieces = [];
-        for (const m of possibleMoves) {
+        for (const m of moveDiff) {
             if (m.captured) {
                 targetedPieces.push(m);
             }

package/dist/utils/SequenceInterpreter.d.ts

@@ -7,7 +7,10 @@ export declare class SequenceInterpreter {
     setContext(context: _TacticContext): void;
     getCaptureSequence(position: Fen, sequence: Move[]): any[];
     identifyWinningSequence(attackerSquares: Square[], attackedSquares: Square[]): SequenceInterpretation | null;
-    private capturedAttackedPieces;
+    protected capturedAttackedPieces(move: Move, attackerSquares: Square[], attackedSquares: Square[]): boolean;
     private isDesparado;
     positionAfterSequence(position: Fen, sequence: string[] | Move[] | null): string;
 }
+export declare class TrapTacticsSequenceInterpreter extends SequenceInterpreter {
+    protected capturedAttackedPieces(move: Move, attackerSquares: Square[], attackedSquares: Square[]): boolean;
+}

package/dist/utils/SequenceInterpreter.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SequenceInterpreter = void 0;
+exports.TrapTacticsSequenceInterpreter = exports.SequenceInterpreter = void 0;
 const chess_js_1 = require("chess.js");
 const _utils_1 = require("./index");
 class SequenceInterpreter {
@@ -66,7 +66,9 @@ class SequenceInterpreter {
     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 (attackerSquares.filter((t) => t === move.from).length > 0 &&
+                s === move.to &&
+                move.captured);
         });
         return capturedSquares.length > 0;
     }
@@ -86,3 +88,13 @@ class SequenceInterpreter {
     }
 }
 exports.SequenceInterpreter = SequenceInterpreter;
+class TrapTacticsSequenceInterpreter extends SequenceInterpreter {
+    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;
+    }
+}
+exports.TrapTacticsSequenceInterpreter = TrapTacticsSequenceInterpreter;

package/dist/utils/TacticContextParser.js

@@ -7,6 +7,13 @@ class TacticContextParser {
     static parse(context, options) {
         const evaluation = this.parseEvaluation(context.position, context.evaluation, options);
         if ("prevEvaluation" in context) {
+            const prevChess = new chess_js_1.Chess(context.prevPosition);
+            try {
+                prevChess.move(context.prevMove);
+            }
+            catch (e) {
+                throw new _chess_tactics_1.ChessTacticsParserError(`prevMove ${context.prevMove.san} is not playable in prevPosition ${context.prevPosition}`, "INVALID_MOVE", { cause: e });
+            }
             const prevEvaluation = this.parseEvaluation(context.prevPosition, context.prevEvaluation, options);
             return {
                 evaluation: evaluation,

package/package.json

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