X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FBenedict.js;h=eb6214629af473e0e36439efd8a1c6352640ece9;hb=3a2a7b5fd3c6bfd0752838094c27e1fb6172d109;hp=8ce7acdeac154a8905525eae4afe27f35052af2a;hpb=2ceec0ec299f93627fbe9a4e278cdb0d943e2b63;p=vchess.git

diff --git a/client/src/variants/Benedict.js b/client/src/variants/Benedict.js
index 8ce7acde..eb621462 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] >= 8) continue;
+      // If this code is reached, rooks and king are on initial position
+
+      const rookPos = this.castleFlags[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 != rookPos; 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]) {
@@ -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);
+  }
 };