X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FPacosako.js;h=70121c9df374934bf20f38f57da067999a5e8dbe;hb=HEAD;hp=ae4fe6ff2bded02455b68b4d03aeb0e9bf301fd6;hpb=6cc34165a3ca6dcad86030c96df8c0f49c1fabad;p=vchess.git

diff --git a/client/src/variants/Pacosako.js b/client/src/variants/Pacosako.js
index ae4fe6ff..70121c9d 100644
--- a/client/src/variants/Pacosako.js
+++ b/client/src/variants/Pacosako.js
@@ -3,6 +3,23 @@ import { randInt } from "@/utils/alea";
 
 export class PacosakoRules extends ChessRules {
 
+  static get Options() {
+    return {
+      select: ChessRules.Options.select,
+      check: [
+        {
+          label: "pacoplay mode",
+          variable: "pacoplay",
+          defaut: false
+        }
+      ]
+    };
+  }
+
+  static AbbreviateOptions(opts) {
+    return (opts["pacoplay"] ? "PP" : "");
+  }
+
   static get IMAGE_EXTENSION() {
     return ".png";
   }
@@ -30,26 +47,25 @@ export class PacosakoRules extends ChessRules {
       x: ['b', 'k'],
       y: ['q', 'q'],
       z: ['q', 'k'],
-      '_': ['k', 'k']
+      '@': ['k', 'k']
     };
   }
 
   static fen2board(f) {
-    // Underscore is character 95, in file w_
-    return f.charCodeAt() <= 95 ? "w" + f.toLowerCase() : "b" + f;
+    // Arobase is character 64
+    return f.charCodeAt() <= 90 ? "w" + f.toLowerCase() : "b" + f;
   }
 
   static IsGoodPosition(position) {
     if (position.length == 0) return false;
     const rows = position.split("/");
     if (rows.length != V.size.x) return false;
-    let kingSymb = ['k', 'g', 'm', 'u', 'x', '_'];
+    let kingSymb = ['k', 'g', 'm', 'u', 'x', 'z', '@'];
     let kings = { 'k': 0, 'K': 0 };
     for (let row of rows) {
       let sumElts = 0;
       for (let i = 0; i < row.length; i++) {
-        const lowR = row[i].toLowerCase
-        if (!!(row[i].toLowerCase().match(/[a-z_]/))) {
+        if (!!(row[i].toLowerCase().match(/[a-z@]/))) {
           sumElts++;
           if (kingSymb.includes(row[i])) kings['k']++;
           // Not "else if", if two kings dancing together
@@ -105,12 +121,12 @@ export class PacosakoRules extends ChessRules {
     this.kingPos = { w: [-1, -1], b: [-1, -1] };
     const fenRows = V.ParseFen(fen).position.split("/");
     const startRow = { 'w': V.size.x - 1, 'b': 0 };
-    const kingSymb = ['k', 'g', 'm', 'u', 'x', '_'];
+    const kingSymb = ['k', 'g', 'm', 'u', 'x', 'z', '@'];
     for (let i = 0; i < fenRows.length; i++) {
       let k = 0;
       for (let j = 0; j < fenRows[i].length; j++) {
         const c = fenRows[i].charAt(j);
-        if (!!(c.toLowerCase().match(/[a-z_]/))) {
+        if (!!(c.toLowerCase().match(/[a-z@]/))) {
           if (kingSymb.includes(c))
             this.kingPos["b"] = [i, k];
           // Not "else if", in case of two kings dancing together
@@ -127,19 +143,24 @@ export class PacosakoRules extends ChessRules {
   }
 
   setOtherVariables(fen) {
-    super.setOtherVariables(fen);
     // Stack of "last move" only for intermediate chaining
     this.lastMoveEnd = [null];
     // Local stack of non-capturing union moves:
     this.umoves = [];
     const umove = V.ParseFen(fen).umove;
-    if (umove == "-") this.umoves.push(null);
-    else {
-      this.umoves.push({
-        start: ChessRules.SquareToCoords(umove.substr(0, 2)),
-        end: ChessRules.SquareToCoords(umove.substr(2))
-      });
+    this.pacoplay = !umove; //"pacoplay.com mode" ?
+    if (!this.pacoplay) {
+      if (umove == "-") this.umoves.push(null);
+      else {
+        this.umoves.push({
+          start: ChessRules.SquareToCoords(umove.substr(0, 2)),
+          end: ChessRules.SquareToCoords(umove.substr(2))
+        });
+      }
     }
+    // Local stack of positions to avoid redundant moves:
+    this.repetitions = [];
+    super.setOtherVariables(fen);
   }
 
   static IsGoodFen(fen) {
@@ -152,12 +173,13 @@ export class PacosakoRules extends ChessRules {
   }
 
   static IsGoodFlags(flags) {
-    // 4 for castle + 16 for pawns
-    return !!flags.match(/^[a-z]{4,4}[01]{16,16}$/);
+    // 4 for castle + 16 for pawns (more permissive, for pacoplay mode)
+    return !!flags.match(/^[a-z]{4,4}[01]{0,16}$/);
   }
 
   setFlags(fenflags) {
     super.setFlags(fenflags); //castleFlags
+    if (this.pacoplay) return;
     this.pawnFlags = {
       w: [...Array(8)], //pawns can move 2 squares?
       b: [...Array(8)]
@@ -170,18 +192,23 @@ export class PacosakoRules extends ChessRules {
   }
 
   aggregateFlags() {
+    if (!this.pacoplay) return super.aggregateFlags();
     return [this.castleFlags, this.pawnFlags];
   }
 
   disaggregateFlags(flags) {
-    this.castleFlags = flags[0];
-    this.pawnFlags = flags[1];
+    if (!this.pacoplay) super.disaggregateFlags(flags);
+    else {
+      this.castleFlags = flags[0];
+      this.pawnFlags = flags[1];
+    }
   }
 
   getUmove(move) {
     if (
       move.vanish.length == 1 &&
-      !(ChessRules.PIECES.includes(move.appear[0].p))
+      !(ChessRules.PIECES.includes(move.appear[0].p)) &&
+      move.appear[0].p == move.vanish[0].p //not a promotion
     ) {
       // An union moving
       return { start: move.start, end: move.end };
@@ -197,17 +224,20 @@ export class PacosakoRules extends ChessRules {
     );
   }
 
-  static GenRandInitFen(randomness) {
+  static GenRandInitFen(options) {
     // Add 16 pawns flags + empty umove:
-    return ChessRules.GenRandInitFen(randomness)
-      .slice(0, -2) + "1111111111111111 - -";
+    const pawnFlags = (options.pacoplay ? "" : "1111111111111111");
+    return ChessRules.GenRandInitFen(options).slice(0, -2) +
+      pawnFlags + " -" + (!options.pacoplay ? " -" : "");
   }
 
   getFlagsFen() {
     let fen = super.getFlagsFen();
-    // Add pawns flags
-    for (let c of ["w", "b"])
-      for (let i = 0; i < 8; i++) fen += (this.pawnFlags[c][i] ? "1" : "0");
+    if (!this.pacoplay) {
+      // Add pawns flags
+      for (let c of ["w", "b"])
+        for (let i = 0; i < 8; i++) fen += (this.pawnFlags[c][i] ? "1" : "0");
+    }
     return fen;
   }
 
@@ -222,11 +252,13 @@ export class PacosakoRules extends ChessRules {
   }
 
   getFen() {
-    return super.getFen() + " " + this.getUmoveFen();
+    const umoveFen = this.pacoplay ? "" : (" " + this.getUmoveFen());
+    return super.getFen() + umoveFen;
   }
 
   getFenForRepeat() {
-    return super.getFenForRepeat() + "_" + this.getUmoveFen();
+    const umoveFen = this.pacoplay ? "" : ("_" + this.getUmoveFen());
+    return super.getFenForRepeat() + umoveFen;
   }
 
   getColor(i, j) {
@@ -354,7 +386,8 @@ export class PacosakoRules extends ChessRules {
         p: cp.p
       })
     ];
-    mv.released = up[c];
+    // In move.end, to be sent to the server
+    mv.end.released = up[c];
     return mv;
   }
 
@@ -369,7 +402,7 @@ export class PacosakoRules extends ChessRules {
     }
     let baseMoves = [];
     const c = this.turn;
-    switch (piece || this.getPiece(x, y)) {
+    switch (piece) {
       case V.PAWN: {
         const firstRank = (c == 'w' ? 7 : 0);
         baseMoves = this.getPotentialPawnMoves([x, y]).filter(m => {
@@ -379,7 +412,8 @@ export class PacosakoRules extends ChessRules {
             (
               m.start.x == firstRank ||
               Math.abs(m.end.x - m.start.x) == 1 ||
-              this.pawnFlags[c][m.start.y]
+              this.pacoplay ||
+              (!this.pacoplay && this.pawnFlags[c][m.start.y])
             )
             &&
             (
@@ -443,7 +477,6 @@ export class PacosakoRules extends ChessRules {
             return;
           // Fix en-passant capture: union type, maybe released piece too
           const cs = [m.end.x + (c == 'w' ? 1 : -1), m.end.y];
-          const color = this.board[cs[0]][cs[1]].charAt(0);
           const code = this.board[cs[0]][cs[1]].charAt(1);
           if (code == V.PAWN) {
             // Simple en-passant capture (usual: just form union)
@@ -451,9 +484,10 @@ export class PacosakoRules extends ChessRules {
             m.appear[0].p = 'a';
           }
           else {
-            // An union pawn + something juste moved two squares
+            // An union pawn + something just moved two squares
+            const color = this.board[cs[0]][cs[1]].charAt(0);
             const up = this.getUnionPieces(color, code);
-            m.released = up[c];
+            m.end.released = up[c];
             let args = [V.PAWN, up[oppCol]];
             if (c == 'b') args = args.reverse();
             const cp = this.getUnionCode(args[0], args[1]);
@@ -468,6 +502,20 @@ export class PacosakoRules extends ChessRules {
     return moves;
   }
 
+  getPotentialKingMoves(sq) {
+    if (!this.pacoplay) return super.getPotentialKingMoves(sq);
+    // Initialize with normal moves, without captures
+    let moves = [];
+    for (let s of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
+      const [i, j] = [sq[0] + s[0], sq[1] + s[1]];
+      if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY)
+        moves.push(this.getBasicMove(sq, [i, j]));
+    }
+    if (this.castleFlags[this.turn].some(v => v < V.size.y))
+      moves = moves.concat(this.getCastleMoves(sq));
+    return moves;
+  }
+
   getEpSquare(moveOrSquare) {
     if (typeof moveOrSquare === "string") {
       const square = moveOrSquare;
@@ -477,11 +525,10 @@ export class PacosakoRules extends ChessRules {
     const move = moveOrSquare;
     const s = move.start,
           e = move.end;
-    const oppCol = V.GetOppCol(this.turn);
     if (
       s.y == e.y &&
       Math.abs(s.x - e.x) == 2 &&
-      this.getPiece(s.x, s.y, oppCol) == V.PAWN
+      this.getPiece(s.x, s.y, this.turn) == V.PAWN
     ) {
       return {
         x: (s.x + e.x) / 2,
@@ -497,7 +544,7 @@ export class PacosakoRules extends ChessRules {
       !!m1 &&
       !(ChessRules.PIECES.includes(m2.appear[0].p)) &&
       m2.vanish.length == 1 &&
-      !m2.released &&
+      !m2.end.released &&
       m1.start.x == m2.end.x &&
       m1.end.x == m2.start.x &&
       m1.start.y == m2.end.y &&
@@ -600,10 +647,23 @@ export class PacosakoRules extends ChessRules {
     // "positions" = array of FENs to detect infinite loops. Example:
     // r1q1k2r/p1Pb1ppp/5n2/1f1p4/AV5P/P1eDP3/3B1PP1/R3K1NR,
     // Bxd2 Bxc3 Bxb4 Bxc3 Bxb4 etc.
-    const newPos = { fen: super.getBaseFen(), piece: released };
-    if (positions.some(p => p.piece == newPos.piece && p.fen == newPos.fen))
+    const newPos = {
+      fen: super.getBaseFen(),
+      piece: released,
+      from: fromSquare
+    };
+    if (
+      positions.some(p => {
+        return (
+          p.piece == newPos.piece &&
+          p.fen == newPos.fen &&
+          p.from == newPos.from
+        );
+      })
+    ) {
       // Start of an infinite loop: exit
       return false;
+    }
     positions.push(newPos);
     const rank = (color == 'w' ? 0 : 7);
     const moves = this.getPotentialMovesFrom(fromSquare);
@@ -611,11 +671,11 @@ export class PacosakoRules extends ChessRules {
       // Found an attack!
       return true;
     for (let m of moves) {
-      if (!!m.released) {
+      if (!!m.end.released) {
         // Turn won't change since !!m.released
         this.play(m);
         const res = this.isAttacked_aux(
-          files, color, positions, [m.end.x, m.end.y], m.released);
+          files, color, positions, [m.end.x, m.end.y], m.end.released);
         this.undo(m);
         if (res) return true;
       }
@@ -649,12 +709,12 @@ export class PacosakoRules extends ChessRules {
             break outerLoop;
           }
           for (let m of moves) {
-            if (!!m.released) {
+            if (!!m.end.released) {
               // Turn won't change since !!m.released
               this.play(m);
               let positions = [];
               res = this.isAttacked_aux(
-                files, color, positions, [m.end.x, m.end.y], m.released);
+                files, color, positions, [m.end.x, m.end.y], m.end.released);
               this.undo(m);
               if (res) break outerLoop;
             }
@@ -666,14 +726,60 @@ export class PacosakoRules extends ChessRules {
     return res;
   }
 
+  isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) {
+    for (let step of steps) {
+      let rx = x + step[0],
+          ry = y + step[1];
+      while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) {
+        rx += step[0];
+        ry += step[1];
+      }
+      if (
+        V.OnBoard(rx, ry) &&
+        this.board[rx][ry] != V.EMPTY &&
+        this.getPiece(rx, ry) == piece &&
+        this.getColor(rx, ry) == color &&
+        this.canTake([rx, ry], [x, y]) //TODO: necessary line?
+                                       //If not, generic method is OK
+      ) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   // Do not consider checks, except to forbid castling
   getCheckSquares() {
     return [];
   }
+
   filterValid(moves) {
     if (moves.length == 0) return [];
-    const L = this.umoves.length; //at least 1: init from FEN
-    return moves.filter(m => !this.oppositeMoves(this.umoves[L - 1], m));
+    const L = (!this.pacoplay ? this.umoves.length : 0);
+    return moves.filter(m => {
+      if (L > 0 && this.oppositeMoves(this.umoves[L - 1], m)) return false;
+      if (!m.end.released) return true;
+      // Check for repetitions:
+      V.PlayOnBoard(this.board, m);
+      const newState = {
+        piece: m.end.released,
+        square: { x: m.end.x, y: m.end.y },
+        position: this.getBaseFen()
+      };
+      const repet =
+        this.repetitions.some(r => {
+          return (
+            r.piece == newState.piece &&
+            (
+              r.square.x == newState.square.x &&
+              r.square.y == newState.square.y
+            ) &&
+            r.position == newState.position
+          );
+        });
+      V.UndoOnBoard(this.board, m);
+      return !repet;
+    });
   }
 
   updateCastleFlags(move, piece) {
@@ -704,14 +810,24 @@ export class PacosakoRules extends ChessRules {
     const c = this.turn;
     const L = this.lastMoveEnd.length;
     const lm = this.lastMoveEnd[L-1];
-    const piece = (!!lm ? lm.p : move.vanish[0].p);
+    // NOTE: lm.p != V.KING, always.
+    const piece =
+      !!lm
+        ? lm.p
+        : this.getPiece(move.vanish[0].x, move.vanish[0].y);
     if (piece == V.KING)
       this.kingPos[c] = [move.appear[0].x, move.appear[0].y];
     this.updateCastleFlags(move, piece);
     const pawnFirstRank = (c == 'w' ? 6 : 1);
-    if (move.start.x == pawnFirstRank)
-      // This move (potentially) turns off a 2-squares pawn flag
+    if (
+      !this.pacoplay &&
+      move.start.x == pawnFirstRank &&
+      piece == V.PAWN &&
+      Math.abs(move.end.x - move.start.x) == 2
+    ) {
+      // This move turns off a 2-squares pawn flag
       this.pawnFlags[c][move.start.y] = false;
+    }
   }
 
   play(move) {
@@ -719,15 +835,31 @@ export class PacosakoRules extends ChessRules {
     this.prePlay(move);
     this.epSquares.push(this.getEpSquare(move));
     // Check if the move is the last of the turn: all cases except releases
-    if (!move.released) {
+    if (!move.end.released) {
       // No more union releases available
       this.turn = V.GetOppCol(this.turn);
       this.movesCount++;
       this.lastMoveEnd.push(null);
     }
-    else this.lastMoveEnd.push(Object.assign({ p: move.released }, move.end));
+    else {
+      this.lastMoveEnd.push({
+        p: move.end.released,
+        x: move.end.x,
+        y: move.end.y
+      });
+    }
     V.PlayOnBoard(this.board, move);
-    this.umoves.push(this.getUmove(move));
+    if (!this.pacoplay) this.umoves.push(this.getUmove(move));
+    if (!move.end.released) this.repetitions = [];
+    else {
+      this.repetitions.push(
+        {
+          piece: move.end.released,
+          square: { x: move.end.x, y: move.end.y },
+          position: this.getBaseFen()
+        }
+      );
+    }
   }
 
   undo(move) {
@@ -735,11 +867,12 @@ export class PacosakoRules extends ChessRules {
     this.disaggregateFlags(JSON.parse(move.flags));
     V.UndoOnBoard(this.board, move);
     this.lastMoveEnd.pop();
-    if (!move.released) {
+    if (!move.end.released) {
       this.turn = V.GetOppCol(this.turn);
       this.movesCount--;
     }
-    this.umoves.pop();
+    if (!this.pacoplay) this.umoves.pop();
+    if (!!move.end.released) this.repetitions.pop();
     this.postUndo(move);
   }
 
@@ -775,14 +908,15 @@ export class PacosakoRules extends ChessRules {
         mv = moves[randInt(moves.length)];
         mvArray.push(mv);
         this.play(mv);
-        if (!!mv.released)
+        if (!!mv.end.released)
           // A piece was just released from an union
           moves = this.getPotentialMovesFrom([mv.end.x, mv.end.y]);
         else break;
       }
       for (let i = mvArray.length - 1; i >= 0; i--) this.undo(mvArray[i]);
-      if (!mv.released) return (mvArray.length > 1 ? mvArray : mvArray[0]);
+      if (!mv.end.released) return (mvArray.length > 1 ? mvArray : mvArray[0]);
     }
+    return null; //never reached
   }
 
   // NOTE: evalPosition() is wrong, but unused since bot plays at random
@@ -820,8 +954,13 @@ export class PacosakoRules extends ChessRules {
     // Add potential promotion indications:
     const firstLastRank = (c == 'w' ? [7, 0] : [0, 7]);
     if (move.end.x == firstLastRank[1] && piece == V.PAWN) {
-      const up = this.getUnionPieces(move.appear[0].c, move.appear[0].p);
-      notation += "=" + up[c].toUpperCase();
+      notation += "=";
+      if (ChessRules.PIECES.includes(move.appear[0].p))
+        notation += move.appear[0].p.toUpperCase();
+      else {
+        const up = this.getUnionPieces(move.appear[0].c, move.appear[0].p);
+        notation += up[c].toUpperCase();
+      }
     }
     else if (
       move.end.x == firstLastRank[0] &&