Flip knights for variants with knightriders (waiting for a better image)

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

diff --git a/client/src/variants/Enpassant.js b/client/src/variants/Enpassant.js
index dc181ca..4c6ca67 100644 (file)
--- a/client/src/variants/Enpassant.js
+++ b/client/src/variants/Enpassant.js
@@ -1,10 +1,10 @@
 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(",");
+      if (squares.length > 2) return false;
       for (let sq of squares) {
         const ep = V.SquareToCoords(sq);
         if (isNaN(ep.x) || !V.OnBoard(ep)) return false;
@@ -13,16 +13,43 @@ export const VariantRules = class EnpassantRules extends ChessRules {
     return true;
   }
 
+  getPpath(b) {
+    return (b[1] == V.KNIGHT ? "Enpassant/" : "") + b;
+  }
+
   getEpSquare(moveOrSquare) {
     if (!moveOrSquare) return undefined;
     if (typeof moveOrSquare === "string") {
       const square = moveOrSquare;
       if (square == "-") return undefined;
-      let res = [];
-      square.split(",").forEach(sq => {
-        res.push(V.SquareToCoords(sq));
-      });
-      return res;
+      // Expand init + dest squares into a full path:
+      const init = V.SquareToCoords(square.substr(0, 2));
+      let newPath = [init];
+      if (square.length == 2) return newPath;
+      const dest = V.SquareToCoords(square.substr(2));
+      const delta = ['x', 'y'].map(i => Math.abs(dest[i] - init[i]));
+      // Check if it's a knight(rider) movement:
+      let step = [0, 0];
+      if (delta[0] > 0 && delta[1] > 0 && delta[0] != delta[1]) {
+        // Knightrider
+        const minShift = Math.min(delta[0], delta[1]);
+        step[0] = (dest.x - init.x) / minShift;
+        step[1] = (dest.y - init.y) / minShift;
+      } else {
+        // "Sliders"
+        step = ['x', 'y'].map((i, idx) => {
+          return (dest[i] - init[i]) / delta[idx] || 0
+        });
+      }
+      let x = init.x + step[0],
+          y = init.y + step[1];
+      while (x != dest.x || y != dest.y) {
+        newPath.push({ x: x, y: y });
+        x += step[0];
+        y += step[1];
+      }
+      newPath.push(dest);
+      return newPath;
     }
     // Argument is a move: all intermediate squares are en-passant candidates,
     // except if the moving piece is a king.
@@ -42,7 +69,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 (
@@ -50,7 +80,7 @@ export const VariantRules = class EnpassantRules extends ChessRules {
       x != move.end.x || y != move.end.y;
       x += step[0], y += step[1]
     ) {
-      res.push({x:x, y:y});
+      res.push({ x: x, y: y });
     }
     // Add final square to know which piece is taken en passant:
     res.push(move.end);
@@ -60,11 +90,10 @@ export const VariantRules = class EnpassantRules extends ChessRules {
   getEnpassantFen() {
     const L = this.epSquares.length;
     if (!this.epSquares[L - 1]) return "-"; //no en-passant
-    let res = "";
-    this.epSquares[L - 1].forEach(sq => {
-      res += V.CoordsToSquare(sq) + ",";
-    });
-    return res.slice(0, -1); //remove last comma
+    const epsq = this.epSquares[L - 1];
+    if (epsq.length <= 2) return epsq.map(V.CoordsToSquare).join("");
+    // Condensate path: just need initial and final squares:
+    return V.CoordsToSquare(epsq[0]) + V.CoordsToSquare(epsq[epsq.length - 1]);
   }
 
   getPotentialMovesFrom([x, y]) {
@@ -113,60 +142,10 @@ export const VariantRules = class EnpassantRules extends ChessRules {
     return moves;
   }
 
-  // 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
+  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];
@@ -185,7 +164,6 @@ export const VariantRules = class EnpassantRules extends ChessRules {
         }
       });
     }
-
     return moves;
   }