X-Git-Url: https://git.auder.net/?p=vchess.git;a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FHiddenqueen.js;h=b180c6fd70b434aa79a7b956b72ae8d75471ebff;hp=fe34fb28c672d6cd8c586d11e8056d39a7cab7f3;hb=4eb0915a0659c8bece6930866a526c5e2c296d9f;hpb=a97bdbda4ecf83645d409b717e36828784d1450d

diff --git a/client/src/variants/Hiddenqueen.js b/client/src/variants/Hiddenqueen.js
index fe34fb28..b180c6fd 100644
--- a/client/src/variants/Hiddenqueen.js
+++ b/client/src/variants/Hiddenqueen.js
@@ -2,7 +2,7 @@ import { ChessRules, PiPo, Move } from "@/base_rules";
 import { ArrayFun } from "@/utils/array";
 import { randInt } from "@/utils/alea";
 
-export const VariantRules = class HiddenqueenRules extends ChessRules {
+export class HiddenqueenRules extends ChessRules {
   // Analyse in Hiddenqueen mode makes no sense
   static get CanAnalyze() {
     return false;
@@ -12,8 +12,12 @@ export const VariantRules = class HiddenqueenRules extends ChessRules {
     return 't';
   }
 
+  static get SomeHiddenMoves() {
+    return true;
+  }
+
   static get PIECES() {
-    return ChessRules.PIECES.concat(Object.values(V.HIDDEN_CODE));
+    return ChessRules.PIECES.concat([V.HIDDEN_QUEEN]);
   }
 
   getPiece(i, j) {
@@ -38,47 +42,66 @@ export const VariantRules = class HiddenqueenRules extends ChessRules {
     return b;
   }
 
+  getEpSquare(moveOrSquare) {
+    if (!moveOrSquare) return undefined;
+    if (typeof moveOrSquare === "string") {
+      const square = moveOrSquare;
+      if (square == "-") return undefined;
+      return V.SquareToCoords(square);
+    }
+    const move = moveOrSquare;
+    const s = move.start,
+          e = move.end;
+    const color = move.vanish[0].c;
+    if (
+      s.y == e.y &&
+      Math.abs(s.x - e.x) == 2 &&
+      ((color == 'w' && s.x == 6) || (color == 'b' && s.x == 1)) &&
+      [V.PAWN, V.HIDDEN_QUEEN].includes(move.vanish[0].p)
+    ) {
+      return {
+        x: (s.x + e.x) / 2,
+        y: s.y
+      };
+    }
+    return undefined; //default
+  }
+
   isValidPawnMove(move) {
     const color = move.vanish[0].c;
     const pawnShift = color == "w" ? -1 : 1;
     const startRank = color == "w" ? V.size.x - 2 : 1;
-    const lastRank = color == "w" ? 0 : V.size.x - 1;
     return (
-      // The queen is discovered if she reaches the 8th rank,
-      // even if this would be a technically valid pawn move.
-      move.end.x != lastRank &&
       (
+        move.end.x - move.start.x == pawnShift &&
         (
-          move.end.x - move.start.x == pawnShift &&
           (
-            (
-              // Normal move
-              move.end.y == move.start.y &&
-              this.board[move.end.x][move.end.y] == V.EMPTY
-            )
-            ||
-            (
-              // Capture
-              Math.abs(move.end.y - move.start.y) == 1 &&
-              this.board[move.end.x][move.end.y] != V.EMPTY
-            )
+            // Normal move
+            move.end.y == move.start.y &&
+            this.board[move.end.x][move.end.y] == V.EMPTY
+          )
+          ||
+          (
+            // Capture
+            Math.abs(move.end.y - move.start.y) == 1 &&
+            this.board[move.end.x][move.end.y] != V.EMPTY
           )
-        )
-        ||
-        (
-          // Two-spaces initial jump
-          move.start.x == startRank &&
-          move.end.y == move.start.y &&
-          move.end.x - move.start.x == 2 * pawnShift &&
-          this.board[move.end.x][move.end.y] == V.EMPTY
         )
       )
+      ||
+      (
+        // Two-spaces initial jump
+        move.start.x == startRank &&
+        move.end.y == move.start.y &&
+        move.end.x - move.start.x == 2 * pawnShift &&
+        this.board[move.end.x][move.end.y] == V.EMPTY
+      )
     );
   }
 
   getPotentialMovesFrom([x, y]) {
     if (this.getPiece(x, y) == V.HIDDEN_QUEEN) {
-      const pawnMoves = super.getPotentialPawnMoves([x, y]);
+      const pawnMoves = this.getPotentialPawnMoves([x, y]);
       let queenMoves = super.getPotentialQueenMoves([x, y]);
       // Remove from queen moves those corresponding to a pawn move:
       queenMoves = queenMoves
@@ -93,14 +116,44 @@ export const VariantRules = class HiddenqueenRules extends ChessRules {
     return super.getPotentialMovesFrom([x, y]);
   }
 
+  getEnpassantCaptures([x, y], shiftX) {
+    const Lep = this.epSquares.length;
+    const epSquare = this.epSquares[Lep - 1];
+    let enpassantMove = null;
+    if (
+      !!epSquare &&
+      epSquare.x == x + shiftX &&
+      Math.abs(epSquare.y - y) == 1
+    ) {
+      enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]);
+      enpassantMove.vanish.push({
+        x: x,
+        y: epSquare.y,
+        // Captured piece may be a hidden queen
+        p: this.board[x][epSquare.y][1],
+        c: this.getColor(x, epSquare.y)
+      });
+    }
+    return !!enpassantMove ? [enpassantMove] : [];
+  }
+
+  getPotentialPawnMoves([x, y]) {
+    const piece = this.getPiece(x, y);
+    const promotions =
+      piece == V.PAWN
+        ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]
+        : [V.QUEEN]; //hidden queen revealed
+    return super.getPotentialPawnMoves([x, y], promotions);
+  }
+
   getPossibleMovesFrom(sq) {
     this.side = this.turn;
     return this.filterValid(this.getPotentialMovesFrom(sq));
   }
 
-  static GenRandInitFen() {
-    let fen = ChessRules.GenRandInitFen();
-    // Place hidden queens at random:
+  static GenRandInitFen(randomness) {
+    let fen = ChessRules.GenRandInitFen(randomness);
+    // Place hidden queens at random (always):
     let hiddenQueenPos = randInt(8);
     let pawnRank = "PPPPPPPP".split("");
     pawnRank[hiddenQueenPos] = "T";
@@ -112,19 +165,18 @@ export const VariantRules = class HiddenqueenRules extends ChessRules {
     return fen;
   }
 
-  updateVariables(move) {
-    super.updateVariables(move);
+  postPlay(move) {
+    super.postPlay(move);
     if (move.vanish.length == 2 && move.vanish[1].p == V.KING)
       // We took opponent king
       this.kingPos[this.turn] = [-1, -1];
   }
 
-  unupdateVariables(move) {
-    super.unupdateVariables(move);
-    const c = move.vanish[0].c;
-    const oppCol = V.GetOppCol(c);
+  preUndo(move) {
+    super.preUndo(move);
+    const oppCol = this.turn;
     if (this.kingPos[oppCol][0] < 0)
-      // Last move took opponent's king:
+      // Move takes opponent's king:
       this.kingPos[oppCol] = [move.vanish[1].x, move.vanish[1].y];
   }
 
@@ -152,4 +204,25 @@ export const VariantRules = class HiddenqueenRules extends ChessRules {
     this.side = this.turn;
     return super.getComputerMove();
   }
+
+  getNotation(move) {
+    // Not using getPiece() method because it would transform HQ into pawn:
+    if (this.board[move.start.x][move.start.y][1] != V.HIDDEN_QUEEN)
+      return super.getNotation(move);
+    const finalSquare = V.CoordsToSquare(move.end);
+    if (move.appear[0].p == V.QUEEN) {
+      return (
+        "Q" +
+        (move.vanish.length > move.appear.length ? "x" : "") +
+        finalSquare
+      );
+    }
+    // Do not reveal hidden queens playing as pawns
+    let notation = "";
+    if (move.vanish.length == 2)
+      // Capture
+      notation = V.CoordToColumn(move.start.y) + "x" + finalSquare;
+    else notation = finalSquare;
+    return notation;
+  }
 };