Fix parseInt() usage, rename Doubleorda --> Ordamirror, implement Clorange variant

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

diff --git a/client/src/variants/Baroque.js b/client/src/variants/Baroque.js
index 031ea72..4ff23a0 100644 (file)
--- a/client/src/variants/Baroque.js
+++ b/client/src/variants/Baroque.js
@@ -38,7 +38,7 @@ export class BaroqueRules extends ChessRules {
             this.kingPos["w"] = [i, k];
             break;
           default: {
-            const num = parseInt(position[i].charAt(j));
+            const num = parseInt(position[i].charAt(j), 10);
             if (!isNaN(num)) k += num - 1;
           }
         }
@@ -87,7 +87,8 @@ export class BaroqueRules extends ChessRules {
           }
           return true; //immobilizer isn't neutralized
         }
-        // Chameleons can't be immobilized twice, because there is only one immobilizer
+        // Chameleons can't be immobilized twice,
+        // because there is only one immobilizer
         if (oppPiece == V.BISHOP && piece == V.IMMOBILIZER) return true;
       }
     }
@@ -130,7 +131,9 @@ export class BaroqueRules extends ChessRules {
     const color = this.turn;
     const oppCol = V.GetOppCol(color);
     moves.forEach(m => {
-      if (!!byChameleon && m.start.x != m.end.x && m.start.y != m.end.y) return; //chameleon not moving as pawn
+      if (!!byChameleon && m.start.x != m.end.x && m.start.y != m.end.y)
+        // Chameleon not moving as pawn
+        return;
       // Try capturing in every direction
       for (let step of steps) {
         const sq2 = [m.end.x + 2 * step[0], m.end.y + 2 * step[1]];
@@ -224,10 +227,11 @@ export class BaroqueRules extends ChessRules {
       ) {
         continue;
       }
-      // last(thing), cur(thing) : stop if "cur" is our color, or beyond board limits,
-      // or if "last" isn't empty and cur neither. Otherwise, if cur is empty then
-      // add move until cur square; if cur is occupied then stop if !!byChameleon and
-      // the square not occupied by a leaper.
+      // last(thing), cur(thing) : stop if "cur" is our color,
+      // or beyond board limits, or if "last" isn't empty and cur neither.
+      // Otherwise, if cur is empty then add move until cur square;
+      // if cur is occupied then stop if !!byChameleon and the square not
+      // occupied by a leaper.
       let last = [i, j];
       let cur = [i + step[0], j + step[1]];
       let vanished = [new PiPo({ x: x, y: y, c: color, p: piece })];
@@ -289,12 +293,7 @@ export class BaroqueRules extends ChessRules {
           mergedMoves[key].vanish.push(m.vanish[i]);
       }
     });
-    // Finally return an array
-    moves = [];
-    Object.keys(mergedMoves).forEach(k => {
-      moves.push(mergedMoves[k]);
-    });
-    return moves;
+    return Object.values(mergedMoves);
   }
 
   addQueenCaptures(moves, byChameleon) {
@@ -416,16 +415,19 @@ export class BaroqueRules extends ChessRules {
             this.getColor(i, j) == color &&
             this.getPiece(i, j) == V.ROOK
           ) {
-            if (this.isImmobilized([i, j])) return false; //because only one rook
-            // Can it reach a capturing square?
-            // Easy but quite suboptimal way (TODO): generate all moves (turn is OK)
+            if (this.isImmobilized([i, j]))
+              // Because only one rook:
+              return false;
+            // Can it reach a capturing square? Easy but quite suboptimal way
+            // (TODO: generate all moves (turn is OK))
             const moves = this.getPotentialMovesFrom([i, j]);
             for (let move of moves) {
               if (
                 (sameRow && move.end.y == y) ||
                 (sameColumn && move.end.x == x)
-              )
+              ) {
                 return true;
+              }
             }
           }
         }
@@ -453,11 +455,13 @@ export class BaroqueRules extends ChessRules {
               if (
                 this.getPiece(i, j) == V.KNIGHT &&
                 !this.isImmobilized([i, j])
-              )
+              ) {
                 return true;
+              }
               continue outerLoop;
             }
-            // [else] Our color, could be captured *if there was an empty space*
+            // [else] Our color,
+            // could be captured *if there was an empty space*
             if (this.board[i + step[0]][j + step[1]] != V.EMPTY)
               continue outerLoop;
             i -= step[0];
@@ -479,9 +483,10 @@ export class BaroqueRules extends ChessRules {
         V.OnBoard(i, j) &&
         this.board[i][j] != V.EMPTY &&
         this.getColor(i, j) == color &&
-        this.getPiece(i, j) == V.BISHOP
+        this.getPiece(i, j) == V.BISHOP &&
+        !this.isImmobilized([i, j])
       ) {
-        return true; //bishops are never immobilized
+        return true;
       }
     }
     return false;
@@ -525,26 +530,10 @@ export class BaroqueRules extends ChessRules {
     return false;
   }
 
-  static get VALUES() {
-    return {
-      p: 1,
-      r: 2,
-      n: 5,
-      b: 3,
-      q: 3,
-      m: 5,
-      k: 1000
-    };
-  }
-
-  static get SEARCH_DEPTH() {
-    return 2;
-  }
-
   static GenRandInitFen(randomness) {
     if (randomness == 0)
       // Deterministic:
-      return "rnbqkbnrm/pppppppp/8/8/8/8/PPPPPPPP/MNBKQBNR w 0";
+      return "rnbkqbnm/pppppppp/8/8/8/8/PPPPPPPP/MNBQKBNR w 0";
 
     let pieces = { w: new Array(8), b: new Array(8) };
     // Shuffle pieces on first and last rank
@@ -567,6 +556,22 @@ export class BaroqueRules extends ChessRules {
     );
   }
 
+  static get VALUES() {
+    return {
+      p: 1,
+      r: 2,
+      n: 5,
+      b: 3,
+      q: 3,
+      m: 5,
+      k: 1000
+    };
+  }
+
+  static get SEARCH_DEPTH() {
+    return 2;
+  }
+
   getNotation(move) {
     const initialSquare = V.CoordsToSquare(move.start);
     const finalSquare = V.CoordsToSquare(move.end);