X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=base_rules.js;h=ae2ca80dfa1405239f46806b8124dcea0e9f7d13;hb=3ca478329f818efdfe2e03ce72c0effa6a8b0c0b;hp=aea3f57bbf641d743e32e818f6cc8aadbdbde1ff;hpb=b8950be593d0663202c886f4252513bf1a499ee1;p=xogo.git

diff --git a/base_rules.js b/base_rules.js
index aea3f57..ae2ca80 100644
--- a/base_rules.js
+++ b/base_rules.js
@@ -97,6 +97,14 @@ export default class ChessRules {
     return true;
   }
 
+  // Allow to take (moving: not disappearing) own pieces?
+  get hasSelfCaptures() {
+    return (
+      this.options["recycle"] ||
+      (this.options["teleport"] && this.subTurnTeleport == 1)
+    );
+  }
+
   get hasReserve() {
     return (
       !!this.options["crazyhouse"] ||
@@ -225,9 +233,9 @@ export default class ChessRules {
       ['r', 'n', 'b', 'q', 'k', 'b', 'n', 'r'],
       {
         randomness: this.options["randomness"],
-        between: {p1: 'k', p2: 'r'},
+        between: [{p1: 'k', p2: 'r'}],
         diffCol: ['b'],
-        flags: ['r']
+        flags: ['r', 'k']
       }
     );
     return {
@@ -316,7 +324,7 @@ export default class ChessRules {
 
   // Flags part of the FEN string
   getFlagsFen() {
-    return ["w", "b"].map(c => {
+    return ['w', 'b'].map(c => {
       return this.castleFlags[c].map(x => x.toString(36)).join("");
     }).join("");
   }
@@ -332,7 +340,7 @@ export default class ChessRules {
     if (o.init)
       return "000000000000";
     return (
-      ["w","b"].map(c => Object.values(this.reserve[c]).join("")).join("")
+      ['w', 'b'].map(c => Object.values(this.reserve[c]).join("")).join("")
     );
   }
 
@@ -1512,12 +1520,8 @@ export default class ChessRules {
     let moves = this.getPotentialMovesOf(piece, [x, y]);
     if (piece == "p" && this.hasEnpassant && this.epSquare)
       Array.prototype.push.apply(moves, this.getEnpassantCaptures([x, y]));
-    if (
-      this.isKing(0, 0, piece) && this.hasCastle &&
-      this.castleFlags[color || this.turn].some(v => v < this.size.y)
-    ) {
+    if (this.isKing(0, 0, piece) && this.hasCastle)
       Array.prototype.push.apply(moves, this.getCastleMoves([x, y]));
-    }
     return this.postProcessPotentialMoves(moves);
   }
 
@@ -1720,10 +1724,7 @@ export default class ChessRules {
       });
       Array.prototype.push.apply(squares, zenCaptures);
     }
-    if (
-      this.options["recycle"] ||
-      (this.options["teleport"] && this.subTurnTeleport == 1)
-    ) {
+    if (this.hasSelfCaptures) {
       const selfCaptures = this.findDestSquares(
         [x, y],
         {
@@ -2010,8 +2011,9 @@ export default class ChessRules {
     return [];
   }
 
-  getCastleMoves([x, y], finalSquares, castleWith) {
+  getCastleMoves([x, y], finalSquares, castleWith, castleFlags) {
     const c = this.getColor(x, y);
+    castleFlags = castleFlags || this.castleFlags[c];
 
     // Castling ?
     const oppCols = this.getOppCols(c);
@@ -2025,12 +2027,12 @@ export default class ChessRules {
       castleSide < 2;
       castleSide++ //large, then small
     ) {
-      if (this.castleFlags[c][castleSide] >= this.size.y)
+      if (castleFlags[castleSide] >= this.size.y)
         continue;
       // If this code is reached, rook and king are on initial position
 
       // NOTE: in some variants this is not a rook
-      const rookPos = this.castleFlags[c][castleSide];
+      const rookPos = castleFlags[castleSide];
       const castlingPiece = this.getPiece(x, rookPos);
       if (
         this.board[x][rookPos] == "" ||
@@ -2233,11 +2235,20 @@ export default class ChessRules {
       this.board[psq.x][psq.y] = psq.c + psq.p;
   }
 
-  updateCastleFlags(move) {
+  // NOTE: arg "castleFlags" for Coregal or Twokings
+  updateCastleFlags(move, castleFlags, king) {
+    castleFlags = castleFlags || this.castleFlags;
+    // If flags already off, no need to re-check:
+    if (
+      Object.values(castleFlags).every(cvals =>
+        cvals.every(val => val >= this.size.y))
+    ) {
+      return;
+    }
     // Update castling flags if start or arrive from/at rook/king locations
     move.appear.concat(move.vanish).forEach(psq => {
-      if (this.isKing(0, 0, psq.p))
-        this.castleFlags[psq.c] = [this.size.y, this.size.y];
+      if ((!!king && psq.p == king) || this.isKing(0, 0, psq.p))
+        castleFlags[psq.c] = [this.size.y, this.size.y];
       // NOTE: not "else if" because king can capture enemy rook...
       let c = "";
       if (psq.x == 0)
@@ -2245,22 +2256,16 @@ export default class ChessRules {
       else if (psq.x == this.size.x - 1)
         c = "w";
       if (c != "") {
-        const fidx = this.castleFlags[c].findIndex(f => f == psq.y);
+        const fidx = castleFlags[c].findIndex(f => f == psq.y);
         if (fidx >= 0)
-          this.castleFlags[c][fidx] = this.size.y;
+          castleFlags[c][fidx] = this.size.y;
       }
     });
   }
 
   prePlay(move) {
-    if (
-      this.hasCastle &&
-      // If flags already off, no need to re-check:
-      Object.values(this.castleFlags).some(cvals =>
-        cvals.some(val => val < this.size.y))
-    ) {
+    if (this.hasCastle)
       this.updateCastleFlags(move);
-    }
     if (this.options["crazyhouse"]) {
       move.vanish.forEach(v => {
         const square = C.CoordsToSquare({x: v.x, y: v.y});