Add unambiguous section in the PGN + some fixes + code formatting and fix typos

[vchess.git] / client / src / variants / Enpassant.js

diff --git a/client/src/variants/Enpassant.js b/client/src/variants/Enpassant.js
index 374a620..5ff4c95 100644 (file)
--- a/client/src/variants/Enpassant.js
+++ b/client/src/variants/Enpassant.js
@@ -1,7 +1,6 @@
 import { ChessRules, PiPo, Move } from "@/base_rules";
 
-export const VariantRules = class EnpassantRules extends ChessRules {
-
+export class EnpassantRules extends ChessRules {
   static IsGoodEnpassant(enpassant) {
     if (enpassant != "-") {
       const squares = enpassant.split(",");
@@ -42,7 +41,10 @@ export const VariantRules = class EnpassantRules extends ChessRules {
       const divisor = Math.min(Math.abs(delta[0]), Math.abs(delta[1]));
       step = [delta[0]/divisor || 0, delta[1]/divisor || 0];
     } else {
-      step = [delta[0]/Math.abs(delta[0]) || 0, delta[1]/Math.abs(delta[1]) || 0];
+      step = [
+        delta[0]/Math.abs(delta[0]) || 0,
+        delta[1]/Math.abs(delta[1]) || 0
+      ];
     }
     let res = [];
     for (
@@ -67,97 +69,6 @@ export const VariantRules = class EnpassantRules extends ChessRules {
     return res.slice(0, -1); //remove last comma
   }
 
-  // TODO: this getPotentialPawnMovesFrom() is mostly duplicated:
-  // it could be split in "capture", "promotion", "enpassant"...
-  getPotentialPawnMoves([x, y]) {
-    const color = this.turn;
-    let moves = [];
-    const [sizeX, sizeY] = [V.size.x, V.size.y];
-    const shiftX = color == "w" ? -1 : 1;
-    const startRank = color == "w" ? sizeX - 2 : 1;
-    const lastRank = color == "w" ? 0 : sizeX - 1;
-
-    const finalPieces =
-      x + shiftX == lastRank
-        ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]
-        : [V.PAWN];
-    // One square forward
-    if (this.board[x + shiftX][y] == V.EMPTY) {
-      for (let piece of finalPieces) {
-        moves.push(
-          this.getBasicMove([x, y], [x + shiftX, y], {
-            c: color,
-            p: piece
-          })
-        );
-      }
-      if (
-        x == startRank &&
-        this.board[x + 2 * shiftX][y] == V.EMPTY
-      ) {
-        // Two squares jump
-        moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
-      }
-    }
-    // Captures
-    for (let shiftY of [-1, 1]) {
-      if (
-        y + shiftY >= 0 &&
-        y + shiftY < sizeY &&
-        this.board[x + shiftX][y + shiftY] != V.EMPTY &&
-        this.canTake([x, y], [x + shiftX, y + shiftY])
-      ) {
-        for (let piece of finalPieces) {
-          moves.push(
-            this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
-              c: color,
-              p: piece
-            })
-          );
-        }
-      }
-    }
-
-    // En passant
-    const Lep = this.epSquares.length;
-    const squares = this.epSquares[Lep - 1];
-    if (!!squares) {
-      const S = squares.length;
-      const taken = squares[S-1];
-      const pipoV = new PiPo({
-        x: taken.x,
-        y: taken.y,
-        p: this.getPiece(taken.x, taken.y),
-        c: this.getColor(taken.x, taken.y)
-      });
-      [...Array(S-1).keys()].forEach(i => {
-        const sq = squares[i];
-        if (sq.x == x + shiftX && Math.abs(sq.y - y) == 1) {
-          let enpassantMove = this.getBasicMove([x, y], [sq.x, sq.y]);
-          enpassantMove.vanish.push(pipoV);
-          moves.push(enpassantMove);
-        }
-      });
-    }
-
-    return moves;
-  }
-
-  // Remove the "onestep" condition: knight promote to knightrider:
-
-  getPotentialKnightMoves(sq) {
-    return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT]);
-  }
-
-  isAttackedByKnight(sq, colors) {
-    return this.isAttackedBySlideNJump(
-      sq,
-      colors,
-      V.KNIGHT,
-      V.steps[V.KNIGHT]
-    );
-  }
-
   getPotentialMovesFrom([x, y]) {
     let moves = super.getPotentialMovesFrom([x,y]);
     // Add en-passant captures from this square:
@@ -204,6 +115,58 @@ export const VariantRules = class EnpassantRules extends ChessRules {
     return moves;
   }
 
+  getEnpassantCaptures([x, y], shiftX) {
+    const Lep = this.epSquares.length;
+    const squares = this.epSquares[Lep - 1];
+    let moves = [];
+    if (!!squares) {
+      const S = squares.length;
+      const taken = squares[S-1];
+      const pipoV = new PiPo({
+        x: taken.x,
+        y: taken.y,
+        p: this.getPiece(taken.x, taken.y),
+        c: this.getColor(taken.x, taken.y)
+      });
+      [...Array(S-1).keys()].forEach(i => {
+        const sq = squares[i];
+        if (sq.x == x + shiftX && Math.abs(sq.y - y) == 1) {
+          let enpassantMove = this.getBasicMove([x, y], [sq.x, sq.y]);
+          enpassantMove.vanish.push(pipoV);
+          moves.push(enpassantMove);
+        }
+      });
+    }
+    return moves;
+  }
+
+  // Remove the "onestep" condition: knight promote to knightrider:
+  getPotentialKnightMoves(sq) {
+    return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT]);
+  }
+
+  filterValid(moves) {
+    const filteredMoves = super.filterValid(moves);
+    // If at least one full move made, everything is allowed:
+    if (this.movesCount >= 2)
+      return filteredMoves;
+    // Else, forbid captures:
+    return filteredMoves.filter(m => m.vanish.length == 1);
+  }
+
+  isAttackedByKnight(sq, color) {
+    return this.isAttackedBySlideNJump(
+      sq,
+      color,
+      V.KNIGHT,
+      V.steps[V.KNIGHT]
+    );
+  }
+
+  static get SEARCH_DEPTH() {
+    return 2;
+  }
+
   static get VALUES() {
     return {
       p: 1,