Fix parseInt() usage, rename Doubleorda --> Ordamirror, implement Clorange variant

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

diff --git a/client/src/variants/Alice.js b/client/src/variants/Alice.js
index d6fb0ac..61fcd01 100644 (file)
--- a/client/src/variants/Alice.js
+++ b/client/src/variants/Alice.js
@@ -34,6 +34,56 @@ export class AliceRules extends ChessRules {
     return (Object.keys(V.ALICE_PIECES).includes(b[1]) ? "Alice/" : "") + b;
   }
 
+  getEpSquare(moveOrSquare) {
+    if (!moveOrSquare) return undefined;
+    if (typeof moveOrSquare === "string") {
+      const square = moveOrSquare;
+      if (square == "-") return undefined;
+      return V.SquareToCoords(square);
+    }
+    // Argument is a move:
+    const move = moveOrSquare;
+    const s = move.start,
+          e = move.end;
+    if (
+      s.y == e.y &&
+      Math.abs(s.x - e.x) == 2 &&
+      // Special conditions: a pawn can be on the other side
+      ['p','s'].includes(move.appear[0].p) &&
+      ['p','s'].includes(move.vanish[0].p)
+    ) {
+      return {
+        x: (s.x + e.x) / 2,
+        y: s.y
+      };
+    }
+    return undefined; //default
+  }
+
+  // king can be l or L (on the other mirror side)
+  static IsGoodPosition(position) {
+    if (position.length == 0) return false;
+    const rows = position.split("/");
+    if (rows.length != V.size.x) return false;
+    let kings = { "k": 0, "K": 0, 'l': 0, 'L': 0 };
+    for (let row of rows) {
+      let sumElts = 0;
+      for (let i = 0; i < row.length; i++) {
+        if (['K','k','L','l'].includes(row[i])) kings[row[i]]++;
+        if (V.PIECES.includes(row[i].toLowerCase())) sumElts++;
+        else {
+          const num = parseInt(row[i], 10);
+          if (isNaN(num)) return false;
+          sumElts += num;
+        }
+      }
+      if (sumElts != V.size.y) return false;
+    }
+    if (kings['k'] + kings['l'] != 1 || kings['K'] + kings['L'] != 1)
+      return false;
+    return true;
+  }
+
   setOtherVariables(fen) {
     super.setOtherVariables(fen);
     const rows = V.ParseFen(fen).position.split("/");
@@ -51,7 +101,7 @@ export class AliceRules extends ChessRules {
               this.kingPos["w"] = [i, k];
               break;
             default: {
-              const num = parseInt(rows[i].charAt(j));
+              const num = parseInt(rows[i].charAt(j), 10);
               if (!isNaN(num)) k += num - 1;
             }
           }
@@ -147,18 +197,9 @@ export class AliceRules extends ChessRules {
         m.vanish.length == 2 &&
         this.board[m.end.x][m.end.y] == V.EMPTY
       ) {
-        m.vanish[1].c = V.GetOppCol(this.getColor(x, y));
-        // In the special case of en-passant, if
-        //  - board1 takes board2 : vanish[1] --> Alice
-        //  - board2 takes board1 : vanish[1] --> normal
-        let van = m.vanish[1];
-        if (mirrorSide == 1 && codes.includes(this.getPiece(van.x, van.y)))
-          van.p = V.ALICE_CODES[van.p];
-        else if (
-          mirrorSide == 2 &&
-          pieces.includes(this.getPiece(van.x, van.y))
-        )
-          van.p = V.ALICE_PIECES[van.p];
+        m.vanish[1].c = V.GetOppCol(this.turn);
+        const [epX, epY] = [m.vanish[1].x, m.vanish[1].y];
+        m.vanish[1].p = this.getPiece(epX, epY);
       }
       return true;
     });
@@ -320,10 +361,9 @@ export class AliceRules extends ChessRules {
 
     // Piece or pawn movement
     let notation = piece.toUpperCase() + pawnMark + captureMark + finalSquare;
-    if (["s", "p"].includes(piece) && !["s", "p"].includes(move.appear[0].p)) {
+    if (["s", "p"].includes(piece) && !["s", "p"].includes(move.appear[0].p))
       // Promotion
       notation += "=" + move.appear[0].p.toUpperCase();
-    }
     return notation;
   }
 };