X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fbase_rules.js;h=734af025a31e4fb9e09171fc7df4263200a631b7;hb=af34341d92d47d14f396e7f4adb81f2a7e9d9a61;hp=d35a91865eeb5f0eed7b5a140599817a62732594;hpb=616561273f216debfeab7f5fc532d0b0a8bc8e2d;p=vchess.git

diff --git a/client/src/base_rules.js b/client/src/base_rules.js
index d35a9186..734af025 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,
@@ -164,6 +166,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);
@@ -260,7 +263,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:
@@ -465,7 +469,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);
   }
@@ -700,7 +704,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
@@ -717,11 +721,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) => {
@@ -734,11 +737,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
@@ -862,7 +877,9 @@ export const ChessRules = class ChessRules {
       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 ||
@@ -882,9 +899,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;
         }
@@ -942,14 +962,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])
@@ -957,7 +975,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
@@ -1149,7 +1173,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);
   }
@@ -1224,10 +1247,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