Add Antiking v1

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

diff --git a/client/src/variants/Benedict.js b/client/src/variants/Benedict.js
index 8ce7acd..f0d4f2b 100644 (file)
--- a/client/src/variants/Benedict.js
+++ b/client/src/variants/Benedict.js
@@ -103,33 +103,85 @@ export const VariantRules = class BenedictRules extends ChessRules {
     return moves;
   }
 
-  getPotentialRookMoves(sq) {
-    return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]);
-  }
+  // No "under check" verifications:
+  getCastleMoves([x, y]) {
+    const c = this.getColor(x, y);
+    if (x != (c == "w" ? V.size.x - 1 : 0) || y != this.INIT_COL_KING[c])
+      return []; //x isn't first rank, or king has moved (shortcut)
 
-  getPotentialKnightMoves(sq) {
-    return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep");
-  }
+    // Castling ?
+    const oppCol = V.GetOppCol(c);
+    let moves = [];
+    let i = 0;
+    // King, then rook:
+    const finalSquares = [
+      [2, 3],
+      [V.size.y - 2, V.size.y - 3]
+    ];
+    castlingCheck: for (
+      let castleSide = 0;
+      castleSide < 2;
+      castleSide++ //large, then small
+    ) {
+      if (this.castleFlags[c][castleSide] >= 8) continue;
+      // If this code is reached, rooks and king are on initial position
 
-  getPotentialBishopMoves(sq) {
-    return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]);
-  }
+      const rookPos = this.castleFlags[c][castleSide];
+      if (this.getColor(x, rookPos) != c)
+        // Rook is here but changed color
+        continue;
 
-  getPotentialQueenMoves(sq) {
-    return this.getSlideNJumpMoves(
-      sq,
-      V.steps[V.ROOK].concat(V.steps[V.BISHOP])
-    );
-  }
+      // Nothing on the path of the king ?
+      const finDist = finalSquares[castleSide][0] - y;
+      let step = finDist / Math.max(1, Math.abs(finDist));
+      for (let i = y; i != finalSquares[castleSide][0]; i += step) {
+        if (
+          this.board[x][i] != V.EMPTY &&
+            // NOTE: next check is enough, because of chessboard constraints
+            (this.getColor(x, i) != c ||
+              ![V.KING, V.ROOK].includes(this.getPiece(x, i)))
+        ) {
+          continue castlingCheck;
+        }
+      }
+
+      // Nothing on the path to the rook?
+      step = castleSide == 0 ? -1 : 1;
+      for (i = y + step; i != rookPos; i += step) {
+        if (this.board[x][i] != V.EMPTY) continue castlingCheck;
+      }
 
-  getPotentialKingMoves(sq) {
-    // Initialize with normal (non-capturing) moves
-    let noCaptures = this.getSlideNJumpMoves(
-      sq,
-      V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
-      "oneStep"
-    );
-    return noCaptures.concat(this.getCastleMoves(sq));
+      // Nothing on final squares, except maybe king and castling rook?
+      for (i = 0; i < 2; i++) {
+        if (
+          this.board[x][finalSquares[castleSide][i]] != V.EMPTY &&
+          this.getPiece(x, finalSquares[castleSide][i]) != V.KING &&
+          finalSquares[castleSide][i] != rookPos
+        ) {
+          continue castlingCheck;
+        }
+      }
+
+      // If this code is reached, castle is valid
+      moves.push(
+        new Move({
+          appear: [
+            new PiPo({ x: x, y: finalSquares[castleSide][0], p: V.KING, c: c }),
+            new PiPo({ x: x, y: finalSquares[castleSide][1], p: V.ROOK, c: c })
+          ],
+          vanish: [
+            new PiPo({ x: x, y: y, p: V.KING, c: c }),
+            new PiPo({ x: x, y: rookPos, p: V.ROOK, c: c })
+          ],
+          end:
+            Math.abs(y - rookPos) <= 2
+              ? { x: x, y: rookPos }
+              : { x: x, y: y + 2 * (castleSide == 0 ? -1 : 1) }
+        })
+      );
+    }
+
+    return moves;
   }
 
   // TODO: appear/vanish description of a move is too verbose for Benedict.
@@ -144,27 +196,32 @@ export const VariantRules = class BenedictRules extends ChessRules {
       let newAppear = [];
       let newVanish = [];
       V.PlayOnBoard(this.board, m);
-      // If castling, m.appear has 2 elements:
-      m.appear.forEach(a => {
-        const flipped = this.findCaptures([a.x, a.y]);
-        flipped.forEach(sq => {
-          const piece = this.getPiece(sq[0],sq[1]);
-          const pipoA = new PiPo({
-            x:sq[0],
-            y:sq[1],
-            c:color,
-            p:piece
+      // If castling, m.appear has 2 elements.
+      // In this case, consider the attacks of moving units only.
+      // (Sometimes the king or rook doesn't move).
+      for (let i = 0; i < m.appear.length; i++) {
+        const a  = m.appear[i];
+        if (m.vanish[i].x != a.x || m.vanish[i].y != a.y) {
+          const flipped = this.findCaptures([a.x, a.y]);
+          flipped.forEach(sq => {
+            const piece = this.getPiece(sq[0],sq[1]);
+            const pipoA = new PiPo({
+              x:sq[0],
+              y:sq[1],
+              c:color,
+              p:piece
+            });
+            const pipoV = new PiPo({
+              x:sq[0],
+              y:sq[1],
+              c:oppCol,
+              p:piece
+            });
+            newAppear.push(pipoA);
+            newVanish.push(pipoV);
           });
-          const pipoV = new PiPo({
-            x:sq[0],
-            y:sq[1],
-            c:oppCol,
-            p:piece
-          });
-          newAppear.push(pipoA);
-          newVanish.push(pipoV);
-        });
-      });
+        }
+      }
       Array.prototype.push.apply(m.appear, newAppear);
       Array.prototype.push.apply(m.vanish, newVanish);
       V.UndoOnBoard(this.board, m);
@@ -209,4 +266,15 @@ export const VariantRules = class BenedictRules extends ChessRules {
     // Stalemate:
     return "1/2";
   }
+
+  getNotation(move) {
+    // Just remove flips:
+    const basicMove = {
+      appear: [move.appear[0]],
+      vanish: [move.vanish[0]],
+      start: move.start,
+      end: move.end
+    };
+    return super.getNotation(basicMove);
+  }
 };