X-Git-Url: https://git.auder.net/?p=vchess.git;a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FBerolina.js;h=8473b13ef2e18757105e9a082a24c3c4e824f538;hp=592b25a684a99278fcc8cd1674c25f2033423cb9;hb=6e47d367d4b1b4500bc46d65b44c5e55b52221bb;hpb=dac395887d96e2d642b209c6db6aaacc3ffacb34

diff --git a/client/src/variants/Berolina.js b/client/src/variants/Berolina.js
index 592b25a6..8473b13e 100644
--- a/client/src/variants/Berolina.js
+++ b/client/src/variants/Berolina.js
@@ -1,17 +1,12 @@
 import { ChessRules } from "@/base_rules";
 
-export const VariantRules = class  BerolinaRules extends ChessRules
-{
+export class BerolinaRules extends ChessRules {
   // En-passant after 2-sq jump
-  getEpSquare(moveOrSquare)
-  {
-    if (!moveOrSquare)
-      return undefined;
-    if (typeof moveOrSquare === "string")
-    {
+  getEpSquare(moveOrSquare) {
+    if (!moveOrSquare) return undefined;
+    if (typeof moveOrSquare === "string") {
       const square = moveOrSquare;
-      if (square == "-")
-        return undefined;
+      if (square == "-") return undefined;
       // Enemy pawn initial column must be given too:
       let res = [];
       const epParts = square.split(",");
@@ -21,117 +16,153 @@ export const VariantRules = class  BerolinaRules extends ChessRules
     }
     // Argument is a move:
     const move = moveOrSquare;
-    const [sx,ex,sy] = [move.start.x,move.end.x,move.start.y];
-    if (this.getPiece(sx,sy) == V.PAWN && Math.abs(sx - ex) == 2)
-    {
-      return
-      [
+    const [sx, ex, sy] = [move.start.x, move.end.x, move.start.y];
+    if (this.getPiece(sx, sy) == V.PAWN && Math.abs(sx - ex) == 2) {
+      return [
         {
-          x: (ex + sx)/2,
-          y: (move.end.y + sy)/2
+          x: (ex + sx) / 2,
+          y: (move.end.y + sy) / 2
         },
+        // The arrival column must be remembered, because
+        // potentially two pawns could be candidates to be captured:
+        // one on our left, and one on our right.
         move.end.y
       ];
     }
     return undefined; //default
   }
 
+  static IsGoodEnpassant(enpassant) {
+    if (enpassant != "-") {
+      const epParts = enpassant.split(",");
+      const epSq = V.SquareToCoords(epParts[0]);
+      if (isNaN(epSq.x) || isNaN(epSq.y) || !V.OnBoard(epSq)) return false;
+      const arrCol = V.ColumnToCoord(epParts[1]);
+      if (isNaN(arrCol) || arrCol < 0 || arrCol >= V.size.y) return false;
+    }
+    return true;
+  }
+
+  getEnpassantFen() {
+    const L = this.epSquares.length;
+    if (!this.epSquares[L - 1]) return "-"; //no en-passant
+    return (
+      V.CoordsToSquare(this.epSquares[L - 1][0]) +
+      "," +
+      V.CoordToColumn(this.epSquares[L - 1][1])
+    );
+  }
+
   // Special pawns movements
-  getPotentialPawnMoves([x,y])
-  {
+  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 firstRank = (color == 'w' ? sizeX-1 : 0);
-    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];
+    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 diagonally
-    for (let shiftY of [-1,1])
-    {
-      if (this.board[x+shiftX][y+shiftY] == V.EMPTY)
-      {
-        for (let piece of finalPieces)
-        {
-          moves.push(this.getBasicMove([x,y], [x+shiftX,y+shiftY],
-            {c:color,p:piece}));
+    for (let shiftY of [-1, 1]) {
+      if (this.board[x + shiftX][y + shiftY] == V.EMPTY) {
+        for (let piece of finalPieces) {
+          moves.push(
+            this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
+              c: color,
+              p: piece
+            })
+          );
         }
-        if (x == startRank && y+2*shiftY>=0 && y+2*shiftY<sizeY
-          && this.board[x+2*shiftX][y+2*shiftY] == V.EMPTY)
-        {
+        if (
+          V.PawnSpecs.twoSquares &&
+          x == startRank &&
+          y + 2 * shiftY >= 0 &&
+          y + 2 * shiftY < sizeY &&
+          this.board[x + 2 * shiftX][y + 2 * shiftY] == V.EMPTY
+        ) {
           // Two squares jump
-          moves.push(this.getBasicMove([x,y], [x+2*shiftX,y+2*shiftY]));
+          moves.push(
+            this.getBasicMove([x, y], [x + 2 * shiftX, y + 2 * shiftY])
+          );
         }
       }
     }
     // Capture
-    if (this.board[x+shiftX][y] != V.EMPTY
-      && this.canTake([x,y], [x+shiftX,y]))
-    {
-      for (let piece of finalPieces)
-        moves.push(this.getBasicMove([x,y], [x+shiftX,y], {c:color,p:piece}));
+    if (
+      this.board[x + shiftX][y] != V.EMPTY &&
+      this.canTake([x, y], [x + shiftX, y])
+    ) {
+      for (let piece of finalPieces) {
+        moves.push(
+          this.getBasicMove([x, y], [x + shiftX, y], { c: color, p: piece })
+        );
+      }
     }
 
-    // En passant
-    const Lep = this.epSquares.length;
-    const epSquare = this.epSquares[Lep-1]; //always at least one element
-    if (!!epSquare && epSquare[0].x == x+shiftX && epSquare[0].y == y
-      && Math.abs(epSquare[1] - y) == 1)
-    {
-      let enpassantMove = this.getBasicMove([x,y], [x+shiftX,y]);
-      enpassantMove.vanish.push({
-        x: x,
-        y: epSquare[1],
-        p: 'p',
-        c: this.getColor(x,epSquare[1])
-      });
-      moves.push(enpassantMove);
+    // Next condition so that other variants could inherit from this class
+    if (V.PawnSpecs.enPassant) {
+      // En passant
+      const Lep = this.epSquares.length;
+      const epSquare = this.epSquares[Lep - 1]; //always at least one element
+      if (
+        !!epSquare &&
+        epSquare[0].x == x + shiftX &&
+        epSquare[0].y == y
+      ) {
+        let enpassantMove = this.getBasicMove([x, y], [x + shiftX, y]);
+        enpassantMove.vanish.push({
+          x: x,
+          y: epSquare[1],
+          p: "p",
+          c: this.getColor(x, epSquare[1])
+        });
+        moves.push(enpassantMove);
+      }
     }
 
     return moves;
   }
 
-  isAttackedByPawn([x,y], colors)
-  {
-    for (let c of colors)
-    {
-      let pawnShift = (c=="w" ? 1 : -1);
-      if (x+pawnShift>=0 && x+pawnShift<V.size.x)
-      {
-        if (this.getPiece(x+pawnShift,y)==V.PAWN
-          && this.getColor(x+pawnShift,y)==c)
-        {
-          return true;
-        }
+  isAttackedByPawn([x, y], color) {
+    let pawnShift = (color == "w" ? 1 : -1);
+    if (x + pawnShift >= 0 && x + pawnShift < V.size.x) {
+      if (
+        this.getPiece(x + pawnShift, y) == V.PAWN &&
+        this.getColor(x + pawnShift, y) == color
+      ) {
+        return true;
       }
     }
     return false;
   }
 
-  getNotation(move)
-  {
+  static get SEARCH_DEPTH() {
+    return 2;
+  }
+
+  getNotation(move) {
     const piece = this.getPiece(move.start.x, move.start.y);
-    if (piece == V.PAWN)
-    {
+    if (piece == V.PAWN) {
       // Pawn move
       const finalSquare = V.CoordsToSquare(move.end);
       let notation = "";
-      if (move.vanish.length == 2) //capture
+      if (move.vanish.length == 2)
+        // Capture
         notation = "Px" + finalSquare;
-      else
-      {
+      else {
         // No capture: indicate the initial square for potential ambiguity
         const startSquare = V.CoordsToSquare(move.start);
         notation = startSquare + finalSquare;
       }
-      if (move.appear[0].p != V.PAWN) //promotion
+      if (move.appear[0].p != V.PAWN)
+        // Promotion
         notation += "=" + move.appear[0].p.toUpperCase();
       return notation;
     }
     return super.getNotation(move); //all other pieces are orthodox
   }
-}
+};