X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fbase_rules.js;h=99de62658f9f3df3df795d50840bde55f1e4483a;hb=107dc1bd5361e2538b1551bdcc37c1e90a444b83;hp=d1348e71927b6bdf410659395bd5e3715f1f5372;hpb=2c5d7b20742b802d9c47916915c1114bcfc9a9c3;p=vchess.git

diff --git a/client/src/base_rules.js b/client/src/base_rules.js
index d1348e71..99de6265 100644
--- a/client/src/base_rules.js
+++ b/client/src/base_rules.js
@@ -47,7 +47,9 @@ export const ChessRules = class ChessRules {
   static get PawnSpecs() {
     return {
       directions: { 'w': -1, 'b': 1 },
+      initShift: { w: 1, b: 1 },
       twoSquares: true,
+      threeSquares: false,
       promotions: [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN],
       canCapture: true,
       captureBackward: false,
@@ -78,6 +80,11 @@ export const ChessRules = class ChessRules {
     return V.ShowMoves;
   }
 
+  // Used for Monochrome variant (TODO: harmonize: !canFlip ==> showFirstTurn)
+  get showFirstTurn() {
+    return false;
+  }
+
   // Some variants always show the same orientation
   static get CanFlip() {
     return true;
@@ -86,6 +93,30 @@ export const ChessRules = class ChessRules {
     return V.CanFlip;
   }
 
+  // For (generally old) variants without checkered board
+  static get Monochrome() {
+    return false;
+  }
+
+  // Some variants require lines drawing
+  static get Lines() {
+    if (V.Monochrome) {
+      let lines = [];
+      // Draw all inter-squares lines
+      for (let i = 0; i <= V.size.x; i++)
+        lines.push([[i, 0], [i, V.size.y]]);
+      for (let j = 0; j <= V.size.y; j++)
+        lines.push([[0, j], [V.size.x, j]]);
+      return lines;
+    }
+    return null;
+  }
+
+  // Some variants use click infos:
+  doClick() {
+    return null;
+  }
+
   static get IMAGE_EXTENSION() {
     // All pieces should be in the SVG format
     return ".svg";
@@ -159,6 +190,7 @@ export const ChessRules = class ChessRules {
     return !!flags.match(/^[a-z]{4,4}$/);
   }
 
+  // NOTE: not with regexp to adapt to different board sizes. (TODO?)
   static IsGoodEnpassant(enpassant) {
     if (enpassant != "-") {
       const ep = V.SquareToCoords(enpassant);
@@ -255,7 +287,8 @@ export const ChessRules = class ChessRules {
   }
 
   // On which squares is color under check ? (for interface)
-  getCheckSquares(color) {
+  getCheckSquares() {
+    const color = this.turn;
     return (
       this.underCheck(color)
         // kingPos must be duplicated, because it may change:
@@ -460,7 +493,7 @@ export const ChessRules = class ChessRules {
       return;
     const fenParsed = V.ParseFen(fen);
     this.board = V.GetBoard(fenParsed.position);
-    this.turn = fenParsed.turn[0]; //[0] to work with MarseilleRules
+    this.turn = fenParsed.turn;
     this.movesCount = parseInt(fenParsed.movesCount);
     this.setOtherVariables(fen);
   }
@@ -695,7 +728,7 @@ export const ChessRules = class ChessRules {
   // Consider all potential promotions:
   addPawnMoves([x1, y1], [x2, y2], moves, promotions) {
     let finalPieces = [V.PAWN];
-    const color = this.turn;
+    const color = this.turn; //this.getColor(x1, y1);
     const lastRank = (color == "w" ? 0 : V.size.x - 1);
     if (x2 == lastRank) {
       // promotions arg: special override for Hiddenqueen variant
@@ -712,11 +745,10 @@ export const ChessRules = class ChessRules {
 
   // What are the pawn moves from square x,y ?
   getPotentialPawnMoves([x, y], promotions) {
-    const color = this.turn;
+    const color = this.turn; //this.getColor(x, y);
     const [sizeX, sizeY] = [V.size.x, V.size.y];
     const pawnShiftX = V.PawnSpecs.directions[color];
     const firstRank = (color == "w" ? sizeX - 1 : 0);
-    const startRank = (color == "w" ? sizeX - 2 : 1);
 
     // Pawn movements in shiftX direction:
     const getPawnMoves = (shiftX) => {
@@ -729,11 +761,23 @@ export const ChessRules = class ChessRules {
           // Next condition because pawns on 1st rank can generally jump
           if (
             V.PawnSpecs.twoSquares &&
-            [startRank, firstRank].includes(x) &&
-            this.board[x + 2 * shiftX][y] == V.EMPTY
+            (
+              (color == 'w' && x >= V.size.x - 1 - V.PawnSpecs.initShift['w'])
+              ||
+              (color == 'b' && x <= V.PawnSpecs.initShift['b'])
+            )
           ) {
-            // Two squares jump
-            moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
+            if (this.board[x + 2 * shiftX][y] == V.EMPTY) {
+              // Two squares jump
+              moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
+              if (
+                V.PawnSpecs.threeSquares &&
+                this.board[x + 3 * shiftX][y] == V.EMPTY
+              ) {
+                // Three squares jump
+                moves.push(this.getBasicMove([x, y], [x + 3 * shiftX, y]));
+              }
+            }
           }
         }
         // Captures
@@ -846,18 +890,20 @@ export const ChessRules = class ChessRules {
 
       // NOTE: in some variants this is not a rook
       const rookPos = this.castleFlags[c][castleSide];
-      const castlingPiece = this.getPiece(x, rookPos);
-      if (this.getColor(x, rookPos) != c)
-        // Rook is here but changed color (see Benedict)
+      if (this.board[x][rookPos] == V.EMPTY || this.getColor(x, rookPos) != c)
+        // Rook is not here, or changed color (see Benedict)
         continue;
 
       // Nothing on the path of the king ? (and no checks)
+      const castlingPiece = this.getPiece(x, rookPos);
       const finDist = finalSquares[castleSide][0] - y;
       let step = finDist / Math.max(1, Math.abs(finDist));
       i = y;
       do {
         if (
-          (!castleInCheck && this.isAttacked([x, i], oppCol)) ||
+          // NOTE: "castling" arg is used by some variants (Monster),
+          // where "isAttacked" is overloaded in an infinite-recursive way.
+          (!castleInCheck && this.isAttacked([x, i], oppCol, "castling")) ||
           (this.board[x][i] != V.EMPTY &&
             // NOTE: next check is enough, because of chessboard constraints
             (this.getColor(x, i) != c ||
@@ -877,9 +923,12 @@ export const ChessRules = class ChessRules {
       // Nothing on final squares, except maybe king and castling rook?
       for (i = 0; i < 2; i++) {
         if (
+          finalSquares[castleSide][i] != rookPos &&
           this.board[x][finalSquares[castleSide][i]] != V.EMPTY &&
-          this.getPiece(x, finalSquares[castleSide][i]) != V.KING &&
-          finalSquares[castleSide][i] != rookPos
+          (
+            this.getPiece(x, finalSquares[castleSide][i]) != V.KING ||
+            this.getColor(x, finalSquares[castleSide][i]) != c
+          )
         ) {
           continue castlingCheck;
         }
@@ -937,14 +986,12 @@ export const ChessRules = class ChessRules {
     });
   }
 
-  // Search for all valid moves considering current turn
-  // (for engine and game end)
-  getAllValidMoves() {
+  getAllPotentialMoves() {
     const color = this.turn;
     let potentialMoves = [];
     for (let i = 0; i < V.size.x; i++) {
       for (let j = 0; j < V.size.y; j++) {
-        if (this.getColor(i, j) == color) {
+        if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
           Array.prototype.push.apply(
             potentialMoves,
             this.getPotentialMovesFrom([i, j])
@@ -952,7 +999,13 @@ export const ChessRules = class ChessRules {
         }
       }
     }
-    return this.filterValid(potentialMoves);
+    return potentialMoves;
+  }
+
+  // Search for all valid moves considering current turn
+  // (for engine and game end)
+  getAllValidMoves() {
+    return this.filterValid(this.getAllPotentialMoves());
   }
 
   // Stop at the first move found
@@ -961,12 +1014,11 @@ export const ChessRules = class ChessRules {
     const color = this.turn;
     for (let i = 0; i < V.size.x; i++) {
       for (let j = 0; j < V.size.y; j++) {
-        if (this.getColor(i, j) == color) {
+        if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
           const moves = this.getPotentialMovesFrom([i, j]);
           if (moves.length > 0) {
-            for (let k = 0; k < moves.length; k++) {
+            for (let k = 0; k < moves.length; k++)
               if (this.filterValid([moves[k]]).length > 0) return true;
-            }
           }
         }
       }
@@ -1008,21 +1060,15 @@ export const ChessRules = class ChessRules {
   }
 
   // Is square x,y attacked by 'color' pawns ?
-  isAttackedByPawn([x, y], color) {
+  isAttackedByPawn(sq, color) {
     const pawnShift = (color == "w" ? 1 : -1);
-    if (x + pawnShift >= 0 && x + pawnShift < V.size.x) {
-      for (let i of [-1, 1]) {
-        if (
-          y + i >= 0 &&
-          y + i < V.size.y &&
-          this.getPiece(x + pawnShift, y + i) == V.PAWN &&
-          this.getColor(x + pawnShift, y + i) == color
-        ) {
-          return true;
-        }
-      }
-    }
-    return false;
+    return this.isAttackedBySlideNJump(
+      sq,
+      color,
+      V.PAWN,
+      [[pawnShift, 1], [pawnShift, -1]],
+      "oneStep"
+    );
   }
 
   // Is square x,y attacked by 'color' rooks ?
@@ -1144,7 +1190,6 @@ export const ChessRules = class ChessRules {
     if (piece == V.KING && move.appear.length > 0) {
       this.kingPos[c][0] = move.appear[0].x;
       this.kingPos[c][1] = move.appear[0].y;
-      return;
     }
     if (V.HasCastle) this.updateCastleFlags(move, piece);
   }
@@ -1219,10 +1264,11 @@ export const ChessRules = class ChessRules {
     return 3;
   }
 
-  getComputerMove() {
+  // 'movesList' arg for some variants to provide a custom list
+  getComputerMove(movesList) {
     const maxeval = V.INFINITY;
     const color = this.turn;
-    let moves1 = this.getAllValidMoves();
+    let moves1 = movesList || this.getAllValidMoves();
 
     if (moves1.length == 0)
       // TODO: this situation should not happen