X-Git-Url: https://git.auder.net/pieces/Checkered/cq.svg?a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FEightpieces.js;h=c83cf5ed48a5b2576ddd1cc3d4766b10d12da5af;hb=afbf3ca7151ef15a9e579b0f913683ab212396c4;hp=ead982998949e75ae4e22da400df820578707a03;hpb=13102cabeb4e8c626f1c849369785c174f7aa512;p=vchess.git

diff --git a/client/src/variants/Eightpieces.js b/client/src/variants/Eightpieces.js
index ead98299..c83cf5ed 100644
--- a/client/src/variants/Eightpieces.js
+++ b/client/src/variants/Eightpieces.js
@@ -1,5 +1,5 @@
 import { ArrayFun } from "@/utils/array";
-import { randInt, shuffle } from "@/utils/alea";
+import { randInt } from "@/utils/alea";
 import { ChessRules, PiPo, Move } from "@/base_rules";
 
 export const VariantRules = class EightpiecesRules extends ChessRules {
@@ -17,6 +17,7 @@ export const VariantRules = class EightpiecesRules extends ChessRules {
     return ChessRules.PIECES.concat([V.JAILER, V.SENTRY, V.LANCER]);
   }
 
+  // Lancer directions *from white perspective*
   static get LANCER_DIRS() {
     return {
       'c': [-1, 0], //north
@@ -71,6 +72,8 @@ export const VariantRules = class EightpiecesRules extends ChessRules {
     super.setOtherVariables(fen);
     // subTurn == 2 only when a sentry moved, and is about to push something
     this.subTurn = 1;
+    // Sentry position just after a "capture" (subTurn from 1 to 2)
+    this.sentryPos = null;
     // Stack pieces' forbidden squares after a sentry move at each turn
     const parsedFen = V.ParseFen(fen);
     if (parsedFen.sentrypush == "-") this.sentryPush = [null];
@@ -83,16 +86,78 @@ export const VariantRules = class EightpiecesRules extends ChessRules {
     }
   }
 
-  canTake([x1,y1], [x2, y2]) {
-    if (this.subTurn == 2)
-      // Sentry push: pieces can capture own color (only)
-      return this.getColor(x1, y1) == this.getColor(x2, y2);
-    return super.canTake([x1,y1], [x2, y2]);
-  }
-
   static GenRandInitFen(randomness) {
-    // TODO: special conditions for 960
-    return "jsfqkbnr/pppppppp/8/8/8/8/PPPPPPPP/JSDQKBNR w 0 1111 - -";
+    if (randomness == 0)
+      // Deterministic:
+      return "jsfqkbnr/pppppppp/8/8/8/8/PPPPPPPP/JSDQKBNR w 0 1111 - -";
+
+    let pieces = { w: new Array(8), b: new Array(8) };
+    // Shuffle pieces on first (and last rank if randomness == 2)
+    for (let c of ["w", "b"]) {
+      if (c == 'b' && randomness == 1) {
+        const lancerIdx = pieces['w'].findIndex(p => {
+          return Object.keys(V.LANCER_DIRS).includes(p);
+        });
+        pieces['b'] =
+          pieces['w'].slice(0, lancerIdx)
+          .concat(['g'])
+          .concat(pieces['w'].slice(lancerIdx + 1));
+        break;
+      }
+
+      let positions = ArrayFun.range(8);
+
+      // Get random squares for bishop and sentry
+      let randIndex = 2 * randInt(4);
+      let bishopPos = positions[randIndex];
+      // The sentry must be on a square of different color
+      let randIndex_tmp = 2 * randInt(4) + 1;
+      let sentryPos = positions[randIndex_tmp];
+      if (c == 'b') {
+        // Check if white sentry is on the same color as ours.
+        // If yes: swap bishop and sentry positions.
+        if ((pieces['w'].indexOf('s') - sentryPos) % 2 == 0)
+          [bishopPos, sentryPos] = [sentryPos, bishopPos];
+      }
+      positions.splice(Math.max(randIndex, randIndex_tmp), 1);
+      positions.splice(Math.min(randIndex, randIndex_tmp), 1);
+
+      // Get random squares for knight and lancer
+      randIndex = randInt(6);
+      const knightPos = positions[randIndex];
+      positions.splice(randIndex, 1);
+      randIndex = randInt(5);
+      const lancerPos = positions[randIndex];
+      positions.splice(randIndex, 1);
+
+      // Get random square for queen
+      randIndex = randInt(4);
+      const queenPos = positions[randIndex];
+      positions.splice(randIndex, 1);
+
+      // Rook, jailer and king positions are now almost fixed,
+      // only the ordering rook-> jailer or jailer->rook must be decided.
+      let rookPos = positions[0];
+      let jailerPos = positions[2];
+      const kingPos = positions[1];
+      if (Math.random() < 0.5) [rookPos, jailerPos] = [jailerPos, rookPos];
+
+      pieces[c][rookPos] = "r";
+      pieces[c][knightPos] = "n";
+      pieces[c][bishopPos] = "b";
+      pieces[c][queenPos] = "q";
+      pieces[c][kingPos] = "k";
+      pieces[c][sentryPos] = "s";
+      // Lancer faces north for white, and south for black:
+      pieces[c][lancerPos] = c == 'w' ? 'c' : 'g';
+      pieces[c][jailerPos] = "j";
+    }
+    return (
+      pieces["b"].join("") +
+      "/pppppppp/8/8/8/8/PPPPPPPP/" +
+      pieces["w"].join("").toUpperCase() +
+      " w 0 1111 - -"
+    );
   }
 
   // Scan kings, rooks and jailers
@@ -152,44 +217,84 @@ export const VariantRules = class EightpiecesRules extends ChessRules {
         this.board[i][j] != V.EMPTY &&
         this.getColor(i, j) == oppCol
       ) {
-        const oppPiece = this.getPiece(i, j);
-        if (oppPiece == V.JAILER) return [i, j];
+        if (this.getPiece(i, j) == V.JAILER) return [i, j];
       }
     }
     return null;
   }
 
-  getPotentialMovesFrom_aux([x, y]) {
+  // Because of the lancers, getPiece() could be wrong:
+  // use board[x][y][1] instead (always valid).
+  getBasicMove([sx, sy], [ex, ey], tr) {
+    let mv = new Move({
+      appear: [
+        new PiPo({
+          x: ex,
+          y: ey,
+          c: tr ? tr.c : this.getColor(sx, sy),
+          p: tr ? tr.p : this.board[sx][sy].charAt(1)
+        })
+      ],
+      vanish: [
+        new PiPo({
+          x: sx,
+          y: sy,
+          c: this.getColor(sx, sy),
+          p: this.board[sx][sy].charAt(1)
+        })
+      ]
+    });
+
+    // The opponent piece disappears if we take it
+    if (this.board[ex][ey] != V.EMPTY) {
+      mv.vanish.push(
+        new PiPo({
+          x: ex,
+          y: ey,
+          c: this.getColor(ex, ey),
+          p: this.board[ex][ey].charAt(1)
+        })
+      );
+    }
+
+    return mv;
+  }
+
+  canIplay(side, [x, y]) {
+    return (
+      (this.subTurn == 1 && this.turn == side && this.getColor(x, y) == side) ||
+      (this.subTurn == 2 && x == this.sentryPos.x && y == this.sentryPos.y)
+    );
+  }
+
+  getPotentialMovesFrom([x,y]) {
+    // At subTurn == 2, jailers aren't effective (Jeff K)
+    if (this.subTurn == 1 && !!this.isImmobilized([x, y])) return [];
+    if (this.subTurn == 2) {
+      // Temporarily change pushed piece color.
+      // (Not using getPiece() because of lancers)
+      var oppCol = this.getColor(x, y);
+      var color = V.GetOppCol(oppCol);
+      var saveXYstate = this.board[x][y];
+      this.board[x][y] = color + this.board[x][y].charAt(1);
+    }
+    let moves = [];
     switch (this.getPiece(x, y)) {
       case V.JAILER:
-        return this.getPotentialJailerMoves([x, y]);
+        moves = this.getPotentialJailerMoves([x, y]);
+        break;
       case V.SENTRY:
-        return this.getPotentialSentryMoves([x, y]);
+        moves = this.getPotentialSentryMoves([x, y]);
+        break;
       case V.LANCER:
-        return this.getPotentialLancerMoves([x, y]);
+        moves = this.getPotentialLancerMoves([x, y]);
+        break;
       default:
-        return super.getPotentialMovesFrom([x, y]);
-    }
-  }
-
-  getPotentialMovesFrom([x,y]) {
-    if (this.subTurn == 1) {
-      if (!!this.isImmobilized([x, y])) return [];
-      return this.getPotentialMovesFrom_aux([x, y]);
+        moves = super.getPotentialMovesFrom([x, y]);
+        break;
     }
-    // subTurn == 2: only the piece pushed by the sentry is allowed to move,
-    // as if the sentry didn't exist
-    if (x != this.sentryPos.x && y != this.sentryPos.y) return [];
-    return this.getPotentialMovesFrom_aux([x,y]);
-  }
-
-  getAllValidMoves() {
-    let moves = super.getAllValidMoves().filter(m => {
-      // Remove jailer captures
-      return m.vanish[0].p != V.JAILER || m.vanish.length == 1;
-    });
     const L = this.sentryPush.length;
-    if (!!this.sentryPush[L-1] && this.subTurn == 1) {
+    if (!!this.sentryPush[L-1]) {
       // Delete moves walking back on sentry push path
       moves = moves.filter(m => {
         if (
@@ -201,32 +306,196 @@ export const VariantRules = class EightpiecesRules extends ChessRules {
         return true;
       });
     }
+    else if (this.subTurn == 2) {
+      // Don't forget to re-add the sentry on the board:
+      // Also fix color of pushed piece afterward:
+      moves.forEach(m => {
+        m.appear.push({x: x, y: y, p: V.SENTRY, c: color});
+        m.appear[0].c = oppCol;
+        m.vanish[0].c = oppCol;
+      });
+    }
     return moves;
   }
 
-  filterValid(moves) {
-    // Disable check tests when subTurn == 2, because the move isn't finished
-    if (this.subTurn == 2) return moves;
-    return super.filterValid(moves);
+  getPotentialPawnMoves([x, y]) {
+    const color = this.getColor(x, y);
+    let moves = [];
+    const [sizeX, sizeY] = [V.size.x, V.size.y];
+    const shiftX = color == "w" ? -1 : 1;
+    const startRank = color == "w" ? sizeX - 2 : 1;
+    const lastRank = color == "w" ? 0 : sizeX - 1;
+
+    const finalPieces =
+      // No promotions after pushes!
+      x + shiftX == lastRank && this.subTurn == 1
+        ?
+          Object.keys(V.LANCER_DIRS).concat(
+          [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN, V.SENTRY, V.JAILER])
+        : [V.PAWN];
+    if (this.board[x + shiftX][y] == V.EMPTY) {
+      // One square forward
+      for (let piece of finalPieces) {
+        moves.push(
+          this.getBasicMove([x, y], [x + shiftX, y], {
+            c: color,
+            p: piece
+          })
+        );
+      }
+      if (
+        x == startRank &&
+        this.board[x + 2 * shiftX][y] == V.EMPTY
+      ) {
+        // Two squares jump
+        moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
+      }
+    }
+    // Captures
+    for (let shiftY of [-1, 1]) {
+      if (
+        y + shiftY >= 0 &&
+        y + shiftY < sizeY &&
+        this.board[x + shiftX][y + shiftY] != V.EMPTY &&
+        this.canTake([x, y], [x + shiftX, y + shiftY])
+      ) {
+        for (let piece of finalPieces) {
+          moves.push(
+            this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
+              c: color,
+              p: piece
+            })
+          );
+        }
+      }
+    }
+
+    // En passant:
+    const Lep = this.epSquares.length;
+    const epSquare = this.epSquares[Lep - 1]; //always at least one element
+    if (
+      !!epSquare &&
+      epSquare.x == x + shiftX &&
+      Math.abs(epSquare.y - y) == 1
+    ) {
+      let enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]);
+      enpassantMove.vanish.push({
+        x: x,
+        y: epSquare.y,
+        p: "p",
+        c: this.getColor(x, epSquare.y)
+      });
+      moves.push(enpassantMove);
+    }
+
+    return moves;
+  }
+
+  // Obtain all lancer moves in "step" direction,
+  // without final re-orientation.
+  getPotentialLancerMoves_aux([x, y], step, tr) {
+    let moves = [];
+    // Add all moves to vacant squares until opponent is met:
+    const oppCol = V.GetOppCol(this.getColor(x, y));
+    let sq = [x + step[0], y + step[1]];
+    while (V.OnBoard(sq[0], sq[1]) && this.getColor(sq[0], sq[1]) != oppCol) {
+      if (this.board[sq[0]][sq[1]] == V.EMPTY)
+        moves.push(this.getBasicMove([x, y], sq, tr));
+      sq[0] += step[0];
+      sq[1] += step[1];
+    }
+    if (V.OnBoard(sq[0], sq[1]))
+      // Add capturing move
+      moves.push(this.getBasicMove([x, y], sq, tr));
+    return moves;
   }
 
   getPotentialLancerMoves([x, y]) {
-    // TODO: add all lancer possible orientations same as pawn promotions,
-    // except if just after a push: allow all movements from init square then
-    return [];
+    let moves = [];
+    // Add all lancer possible orientations, similar to pawn promotions.
+    // Except if just after a push: allow all movements from init square then
+    const L = this.sentryPush.length;
+    if (!!this.sentryPush[L-1]) {
+      // Maybe I was pushed
+      const pl = this.sentryPush[L-1].length;
+      if (
+        this.sentryPush[L-1][pl-1].x == x &&
+        this.sentryPush[L-1][pl-1].y == y
+      ) {
+        // I was pushed: allow all directions (for this move only), but
+        // do not change direction after moving.
+        const color = this.getColor(x, y);
+        Object.values(V.LANCER_DIRS).forEach(step => {
+          const dirCode = Object.keys(V.LANCER_DIRS).find(k => {
+            return (V.LANCER_DIRS[k][0] == step[0] && V.LANCER_DIRS[k][1] == step[1]);
+          });
+          Array.prototype.push.apply(
+            moves,
+            this.getPotentialLancerMoves_aux([x, y], step, { p: dirCode, c: color })
+          );
+        });
+        return moves;
+      }
+    }
+    // I wasn't pushed: standard lancer move
+    const dirCode = this.board[x][y][1];
+    const monodirMoves =
+      this.getPotentialLancerMoves_aux([x, y], V.LANCER_DIRS[dirCode]);
+    // Add all possible orientations aftermove except if I'm being pushed
+    if (this.subTurn == 1) {
+      monodirMoves.forEach(m => {
+        Object.keys(V.LANCER_DIRS).forEach(k => {
+          let mk = JSON.parse(JSON.stringify(m));
+          mk.appear[0].p = k;
+          moves.push(mk);
+        });
+      });
+      return moves;
+    } else return monodirMoves;
   }
 
   getPotentialSentryMoves([x, y]) {
     // The sentry moves a priori like a bishop:
     let moves = super.getPotentialBishopMoves([x, y]);
-    // ...but captures are replaced by special move
-    // "appear = [], vanish = init square" to let the pushed piece move then.
-    // TODO
+    // ...but captures are replaced by special move, if and only if
+    // "captured" piece can move now, considered as the capturer unit.
+    // --> except is subTurn == 2, in this case I don't push anything.
+    if (this.subTurn == 2) return moves.filter(m => m.vanish.length == 1);
+    moves.forEach(m => {
+      if (m.vanish.length == 2) {
+        // Temporarily cancel the sentry capture:
+        m.appear.pop();
+        m.vanish.pop();
+      }
+    });
+    // Can the pushed unit make any move? ...resulting in a non-self-check?
+    const color = this.getColor(x, y);
+    const fMoves = moves.filter(m => {
+      // Sentry push?
+      if (m.appear.length == 0) {
+        let res = false;
+        this.play(m);
+        let moves2 = this.filterValid(
+          this.getPotentialMovesFrom([m.end.x, m.end.y]));
+        for (let m2 of moves2) {
+          this.play(m2);
+          res = !this.underCheck(color);
+          this.undo(m2);
+          if (res) break;
+        }
+        this.undo(m);
+        return res;
+      }
+      return true;
+    });
+    return fMoves;
   }
 
   getPotentialJailerMoves([x, y]) {
-    // Captures are removed afterward:
-    return super.getPotentialRookMoves([x, y]);
+    return super.getPotentialRookMoves([x, y]).filter(m => {
+      // Remove jailer captures
+      return m.vanish[0].p != V.JAILER || m.vanish.length == 1;
+    });
   }
 
   getPotentialKingMoves([x, y]) {
@@ -326,45 +595,274 @@ export const VariantRules = class EightpiecesRules extends ChessRules {
     return moves;
   }
 
+  filterValid(moves) {
+    // Disable check tests for sentry pushes,
+    // because in this case the move isn't finished
+    let movesWithoutSentryPushes = [];
+    let movesWithSentryPushes = [];
+    moves.forEach(m => {
+      if (m.appear.length > 0) movesWithoutSentryPushes.push(m);
+      else movesWithSentryPushes.push(m);
+    });
+    const filteredMoves = super.filterValid(movesWithoutSentryPushes);
+    // If at least one full move made, everything is allowed:
+    if (this.movesCount >= 2)
+      return filteredMoves.concat(movesWithSentryPushes);
+    // Else, forbid checks and captures:
+    const oppCol = V.GetOppCol(this.turn);
+    return filteredMoves.filter(m => {
+      if (m.vanish.length == 2 && m.appear.length == 1) return false;
+      this.play(m);
+      const res = !this.underCheck(oppCol);
+      this.undo(m);
+      return res;
+    }).concat(movesWithSentryPushes);
+  }
+
+  getAllValidMoves() {
+    if (this.subTurn == 1) return super.getAllValidMoves();
+    // Sentry push:
+    const sentrySq = [this.sentryPos.x, this.sentryPos.y];
+    return this.filterValid(this.getPotentialMovesFrom(sentrySq));
+  }
+
   updateVariables(move) {
-    super.updateVariables(move);
-    if (this.subTurn == 2) {
-      // A piece is pushed:
-      // TODO: push array of squares between start and end of move, included
-      // (except if it's a pawn)
-      this.sentryPush.push([]); //TODO
-      this.subTurn = 1;
-    } else {
-      if (move.appear.length == 0  && move.vanish.length == 1) {
-        // Special sentry move: subTurn <- 2, and then move pushed piece
-        this.subTurn = 2;
-      }
-      // Else: normal move.
+    const c = this.turn;
+    const piece = move.vanish[0].p;
+    const firstRank = (c == "w" ? V.size.x - 1 : 0);
+
+    // Update king position + flags
+    if (piece == V.KING) {
+      this.kingPos[c][0] = move.appear[0].x;
+      this.kingPos[c][1] = move.appear[0].y;
+      this.castleFlags[c] = [false, false];
+      return;
+    }
+
+    // Update castling flags if rook or jailer moved (or is captured)
+    const oppCol = V.GetOppCol(c);
+    const oppFirstRank = V.size.x - 1 - firstRank;
+    let flagIdx = 0;
+    if (
+      // Our rook moves?
+      move.start.x == firstRank &&
+      this.INIT_COL_ROOK[c] == move.start.y
+    ) {
+      if (this.INIT_COL_ROOK[c] > this.INIT_COL_JAILER[c]) flagIdx++;
+      this.castleFlags[c][flagIdx] = false;
+    } else if (
+      // Our jailer moves?
+      move.start.x == firstRank &&
+      this.INIT_COL_JAILER[c] == move.start.y
+    ) {
+      if (this.INIT_COL_JAILER[c] > this.INIT_COL_ROOK[c]) flagIdx++;
+      this.castleFlags[c][flagIdx] = false;
+    } else if (
+      // We took opponent's rook?
+      move.end.x == oppFirstRank &&
+      this.INIT_COL_ROOK[oppCol] == move.end.y
+    ) {
+      if (this.INIT_COL_ROOK[oppCol] > this.INIT_COL_JAILER[oppCol]) flagIdx++;
+      this.castleFlags[oppCol][flagIdx] = false;
+    } else if (
+      // We took opponent's jailer?
+      move.end.x == oppFirstRank &&
+      this.INIT_COL_JAILER[oppCol] == move.end.y
+    ) {
+      if (this.INIT_COL_JAILER[oppCol] > this.INIT_COL_ROOK[oppCol]) flagIdx++;
+      this.castleFlags[oppCol][flagIdx] = false;
     }
+
+    if (move.appear.length == 0 && move.vanish.length == 1) {
+      // The sentry is about to push a piece: subTurn goes from 1 to 2
+      this.sentryPos = { x: move.end.x, y: move.end.y };
+    } else if (this.subTurn == 2) {
+      // A piece is pushed: forbid array of squares between start and end
+      // of move, included (except if it's a pawn)
+      let squares = [];
+      if (move.vanish[0].p != V.PAWN) {
+        if ([V.KNIGHT,V.KING].includes(move.vanish[0].p))
+          // short-range pieces: just forbid initial square
+          squares.push(move.start);
+        else {
+          const deltaX = move.end.x - move.start.x;
+          const deltaY = move.end.y - move.start.y;
+          const step = [
+            deltaX / Math.abs(deltaX) || 0,
+            deltaY / Math.abs(deltaY) || 0
+          ];
+          for (
+            let sq = {x: move.start.x, y: move.start.y};
+            sq.x != move.end.x && sq.y != move.end.y;
+            sq.x += step[0], sq.y += step[1]
+          ) {
+            squares.push(sq);
+          }
+        }
+        // Add end square as well, to know if I was pushed (useful for lancers)
+        squares.push(move.end);
+      }
+      this.sentryPush.push(squares);
+    } else this.sentryPush.push(null);
+  }
+
+  // TODO: cleaner (global) update/unupdate variables logic, rename...
+  unupdateVariables(move) {
+    super.unupdateVariables(move);
+    this.sentryPush.pop();
   }
 
   play(move) {
     move.flags = JSON.stringify(this.aggregateFlags());
     this.epSquares.push(this.getEpSquare(move));
     V.PlayOnBoard(this.board, move);
-    // TODO: turn changes only if not a sentry push or subTurn == 2
-      //this.turn = V.GetOppCol(this.turn);
-    this.movesCount++;
     this.updateVariables(move);
+    // Is it a sentry push? (useful for undo)
+    move.sentryPush = (this.subTurn == 2);
+    if (this.subTurn == 1) this.movesCount++;
+    if (move.appear.length == 0 && move.vanish.length == 1) this.subTurn = 2;
+    else {
+      // Turn changes only if not a sentry "pre-push"
+      this.turn = V.GetOppCol(this.turn);
+      this.subTurn = 1;
+    }
   }
 
   undo(move) {
     this.epSquares.pop();
     this.disaggregateFlags(JSON.parse(move.flags));
     V.UndoOnBoard(this.board, move);
-    // TODO: here too, take care of turn. If undoing when subTurn == 2,
-    // do not change turn (this shouldn't happen anyway).
-    // ==> normal undo() should be ok.
-    //this.turn = V.GetOppCol(this.turn);
-    this.movesCount--;
+    const L = this.sentryPush.length;
+    // Decrement movesCount except if the move is a sentry push
+    if (!move.sentryPush) this.movesCount--;
+    // Turn changes only if not undoing second part of a sentry push
+    if (!move.sentryPush || this.subTurn == 1)
+      this.turn = V.GetOppCol(this.turn);
     this.unupdateVariables(move);
   }
 
+  isAttacked(sq, colors) {
+    return (
+      super.isAttacked(sq, colors) ||
+      this.isAttackedByLancer(sq, colors) ||
+      this.isAttackedBySentry(sq, colors)
+    );
+  }
+
+  isAttackedByLancer([x, y], colors) {
+    for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
+      // If in this direction there are only enemy pieces and empty squares,
+      // and we meet a lancer: can he reach us?
+      // NOTE: do not stop at first lancer, there might be several!
+      let coord = { x: x + step[0], y: y + step[1] };
+      let lancerPos = [];
+      while (
+        V.OnBoard(coord.x, coord.y) &&
+        (
+          this.board[coord.x][coord.y] == V.EMPTY ||
+          colors.includes(this.getColor(coord.x, coord.y))
+        )
+      ) {
+        lancerPos.push(coord);
+      }
+      for (let xy of lancerPos) {
+        const dir = V.LANCER_DIRS[this.board[xy.x][xy.y].charAt(1)];
+        if (dir[0] == -step[0] && dir[1] == -step[1]) return true;
+      }
+    }
+    return false;
+  }
+
+  // Helper to check sentries attacks:
+  selfAttack([x1, y1], [x2, y2]) {
+    const color = this.getColor(x1, y1);
+    const sliderAttack = (allowedSteps, lancer) => {
+      const deltaX = x2 - x1;
+      const deltaY = y2 - y1;
+      const step = [ deltaX / Math.abs(deltaX), deltaY / Math.abs(deltaY) ];
+      if (allowedStep.every(st => st[0] != step[0] || st[1] != step[1]))
+        return false;
+      let sq = [ x1 = step[0], y1 + step[1] ];
+      while (sq[0] != x2 && sq[1] != y2) {
+        if (
+          (!lancer && this.board[sq[0]][sq[1]] != V.EMPTY) ||
+          (!!lancer && this.getColor(sq[0], sq[1]) != color)
+        ) {
+          return false;
+        }
+      }
+      return true;
+    };
+    switch (this.getPiece(x1, y1)) {
+      case V.PAWN: {
+        // Pushed pawns move as enemy pawns
+        const shift = (color == 'w' ? 1 : -1);
+        return (x1 + shift == x2 && Math.abs(y1 - y2) == 1);
+      }
+      case V.KNIGHT: {
+        const deltaX = Math.abs(x1 - x2);
+        const deltaY = Math.abs(y1 - y2);
+        return (
+          deltaX + deltaY == 3 &&
+          [1, 2].includes(deltaX) &&
+          [1, 2].includes(deltaY)
+        );
+      }
+      case V.ROOK:
+        return sliderAttack(V.steps[V.ROOK]);
+      case V.BISHOP:
+        return sliderAttack(V.steps[V.BISHOP]);
+      case V.QUEEN:
+        return sliderAttack(V.steps[V.ROOK].concat(V.steps[V.BISHOP]));
+      case V.LANCER: {
+        // Special case: as long as no enemy units stands in-between, it attacks
+        // (if it points toward the king).
+        const allowedStep = V.LANCER_DIRS[this.board[x1][y1].charAt(1)];
+        return sliderAttack([allowedStep], "lancer");
+      }
+      // No sentries or jailer tests: they cannot self-capture
+    }
+    return false;
+  }
+
+  isAttackedBySentry([x, y], colors) {
+    // Attacked by sentry means it can self-take our king.
+    // Just check diagonals of enemy sentry(ies), and if it reaches
+    // one of our pieces: can I self-take?
+    const color = V.GetOppCol(colors[0]);
+    let candidates = [];
+    for (let i=0; i<V.size.x; i++) {
+      for (let j=0; j<V.size.y; j++) {
+        if (
+          this.getPiece(i,j) == V.SENTRY &&
+          colors.includes(this.getColor(i,j))
+        ) {
+          for (let step of V.steps[V.BISHOP]) {
+            let sq = [ i + step[0], j + step[1] ];
+            while (
+              V.OnBoard(sq[0], sq[1]) &&
+              this.board[sq[0]][sq[1]] == V.EMPTY
+            ) {
+              sq[0] += step[0];
+              sq[1] += step[1];
+            }
+            if (
+              V.OnBoard(sq[0], sq[1]) &&
+              this.getColor(sq[0], sq[1]) == color
+            ) {
+              candidates.push(sq);
+            }
+          }
+        }
+      }
+    }
+    for (let c of candidates)
+      if (this.selfAttack(c, [x, y])) return true;
+    return false;
+  }
+
+  // Jailer doesn't capture or give check
+
   static get VALUES() {
     return Object.assign(
       { l: 4.8, s: 2.8, j: 3.8 }, //Jeff K. estimations
@@ -372,6 +870,50 @@ export const VariantRules = class EightpiecesRules extends ChessRules {
     );
   }
 
+  getComputerMove() {
+    const maxeval = V.INFINITY;
+    const color = this.turn;
+    let moves1 = this.getAllValidMoves();
+
+    if (moves1.length == 0)
+      // TODO: this situation should not happen
+      return null;
+
+    const setEval = (move) => {
+      const score = this.getCurrentScore();
+      if (score != "*") {
+        move.eval =
+          score == "1/2"
+            ? 0
+            : (score == "1-0" ? 1 : -1) * maxeval;
+      } else move[i].eval = this.evalPosition();
+    };
+
+    // Just search_depth == 1 (because of sentries. TODO: can do better...)
+    moves1.forEach(m1 => {
+      this.play(m1);
+      if (this.subTurn == 1) setEval(m1);
+      else {
+        // Need to play every pushes and count:
+        const moves2 = this.getAllValidMoves();
+        moves2.forEach(m2 => {
+          this.play(m2);
+          setEval(m1);
+          this.undo(m2);
+        });
+      }
+      this.undo(m1);
+    });
+
+    moves1.sort((a, b) => {
+      return (color == "w" ? 1 : -1) * (b.eval - a.eval);
+    });
+    let candidates = [0];
+    for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++)
+      candidates.push(j);
+    return moves1[candidates[randInt(candidates.length)]];
+  }
+
   getNotation(move) {
     // Special case "king takes jailer" is a pass move
     if (move.appear.length == 0 && move.vanish.length == 0) return "pass";