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

diff --git a/client/src/variants/Hiddenqueen.js b/client/src/variants/Hiddenqueen.js
index fe34fb28..15d9b1e9 100644
--- a/client/src/variants/Hiddenqueen.js
+++ b/client/src/variants/Hiddenqueen.js
@@ -42,43 +42,37 @@ export const VariantRules = class HiddenqueenRules extends ChessRules {
     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 +87,89 @@ export const VariantRules = class HiddenqueenRules extends ChessRules {
     return super.getPotentialMovesFrom([x, y]);
   }
 
+  // TODO: find a more general way to describe pawn movements to avoid
+  // re-writing almost the same function for several variants.
+  getPotentialPawnMoves([x, y]) {
+    const color = this.turn;
+    const piece = this.getPiece(x, y);
+    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
+        ? piece == V.PAWN
+          ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]
+          : [V.QUEEN] //hidden queen revealed
+        : [piece]; //V.PAWN
+    if (this.board[x + shiftX][y] == V.EMPTY) {
+      // One square forward
+      for (let p of finalPieces) {
+        moves.push(
+          this.getBasicMove([x, y], [x + shiftX, y], {
+            c: color,
+            p: p
+          })
+        );
+      }
+      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 p of finalPieces) {
+          moves.push(
+            this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
+              c: color,
+              p: p
+            })
+          );
+        }
+      }
+    }
+
+    // En passant
+    const Lep = this.epSquares.length;
+    const epSquare = this.epSquares[Lep - 1]; //always at least one element
+    if (
+      !!epSquare &&
+      epSquare.x == x + shiftX &&
+      Math.abs(epSquare.y - y) == 1
+    ) {
+      let enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]);
+      enpassantMove.vanish.push({
+        x: x,
+        y: epSquare.y,
+        p: "p",
+        c: this.getColor(x, epSquare.y)
+      });
+      moves.push(enpassantMove);
+    }
+
+    return moves;
+  }
+
   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 +181,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 +220,12 @@ export const VariantRules = class HiddenqueenRules extends ChessRules {
     this.side = this.turn;
     return super.getComputerMove();
   }
+
+  getNotation(move) {
+    const notation = super.getNotation(move);
+    if (notation.charAt(0) == 'T')
+      // Do not reveal hidden queens
+      return notation.substr(1);
+    return notation;
+  }
 };