X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FBenedict.js;h=4a31fceb6a7a5f4e105d6d36aa6f4ef1bc93d0e0;hb=620a88ede2ad25e66d9cbb521388ee53e4a564c0;hp=fbeef895522204565f4ab050f9bcf4bd12fff3c4;hpb=1af00c56319683edd9215457b2c84840215399ab;p=vchess.git

diff --git a/client/src/variants/Benedict.js b/client/src/variants/Benedict.js
index fbeef895..4a31fceb 100644
--- a/client/src/variants/Benedict.js
+++ b/client/src/variants/Benedict.js
@@ -132,6 +132,87 @@ export const VariantRules = class BenedictRules extends ChessRules {
     return noCaptures.concat(this.getCastleMoves(sq));
   }
 
+  // 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)
+
+    // 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]) continue;
+      // If this code is reached, rooks and king are on initial position
+
+      const rookPos = this.INIT_COL_ROOK[c][castleSide];
+      if (this.getColor(x, rookPos) != c)
+        // Rook is here but changed color
+        continue;
+
+      // 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 != this.INIT_COL_ROOK[c][castleSide]; i += step) {
+        if (this.board[x][i] != V.EMPTY) continue castlingCheck;
+      }
+
+      // 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.
   // => Would need a new "flipped" array, to be passed in Game.vue...
   getPotentialMovesFrom([x, y]) {
@@ -140,9 +221,9 @@ export const VariantRules = class BenedictRules extends ChessRules {
     // Get all moves from x,y without captures:
     let moves = super.getPotentialMovesFrom([x, y]);
     // Add flips:
-    let newAppear = [];
-    let newVanish = [];
     moves.forEach(m => {
+      let newAppear = [];
+      let newVanish = [];
       V.PlayOnBoard(this.board, m);
       // If castling, m.appear has 2 elements:
       m.appear.forEach(a => {
@@ -164,9 +245,9 @@ export const VariantRules = class BenedictRules extends ChessRules {
           newAppear.push(pipoA);
           newVanish.push(pipoV);
         });
-        Array.prototype.push.apply(m.appear, newAppear);
-        Array.prototype.push.apply(m.vanish, newVanish);
       });
+      Array.prototype.push.apply(m.appear, newAppear);
+      Array.prototype.push.apply(m.vanish, newVanish);
       V.UndoOnBoard(this.board, m);
     });
     return moves;
@@ -209,4 +290,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);
+  }
 };