+ 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) {
+ // Delete moves walking back on sentry push path
+ moves = moves.filter(m => {
+ if (
+ m.vanish[0].p != V.PAWN &&
+ this.sentryPush[L-1].some(sq => sq.x == m.end.x && sq.y == m.end.y)
+ ) {
+ return false;
+ }
+ return true;
+ });
+ }
+ return moves;
+ }
+
+ filterValid(moves) {
+ // Disable check tests when subTurn == 2, because the move isn't finished
+ if (this.subTurn == 2) return moves;
+ const filteredMoves = super.filterValid(moves);
+ // If at least one full move made, everything is allowed:
+ if (this.movesCount >= 2) return filteredMoves;
+ // Else, forbid check 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;
+ });
+ }
+
+ // Obtain all lancer moves in "step" direction,
+ // without final re-orientation.
+ getPotentialLancerMoves_aux([x, y], step) {
+ let moves = [];
+ // Add all moves to vacant squares until opponent is met:
+ const oppCol = V.GetOppCol(this.turn);
+ 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));
+ 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));
+ return moves;
+ }
+
+ getPotentialLancerMoves([x, y]) {
+ let moves = [];
+ // Add all lancer possible orientations, similar to pawn promotions.
+ // Except if just after a push: allow all movements from init square then
+ if (!!this.sentryPath[L-1]) {
+ // Maybe I was pushed
+ const pl = this.sentryPath[L-1].length;
+ if (
+ this.sentryPath[L-1][pl-1].x == x &&
+ this.sentryPath[L-1][pl-1].y == y
+ ) {
+ // I was pushed: allow all directions (for this move only), but
+ // do not change direction after moving.
+ Object.values(V.LANCER_DIRS).forEach(step => {
+ Array.prototype.push.apply(
+ moves,
+ this.getPotentialLancerMoves_aux([x, y], step)
+ );
+ });
+ 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:
+ 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;
+ }
+
+ getPotentialSentryMoves([x, y]) {
+ // The sentry moves a priori like a bishop:
+ let moves = super.getPotentialBishopMoves([x, y]);
+ // ...but captures are replaced by special move
+ moves.forEach(m => {
+ if (m.vanish.length == 2) {
+ // Temporarily cancel the sentry capture:
+ m.appear.pop();
+ m.vanish.pop();
+ }
+ });
+ return moves;
+ }
+
+ getPotentialJailerMoves([x, y]) {
+ // Captures are removed afterward:
+ return super.getPotentialRookMoves([x, y]);
+ }
+
+ getPotentialKingMoves([x, y]) {
+ let moves = super.getPotentialKingMoves([x, y]);
+ // Augment with pass move is the king is immobilized:
+ const jsq = this.isImmobilized([x, y]);
+ if (!!jsq) {
+ moves.push(
+ new Move({
+ appear: [],
+ vanish: [],
+ start: { x: x, y: y },
+ end: { x: jsq[0], y: jsq[1] }
+ })
+ );
+ }
+ return moves;
+ }
+
+ // Adapted: castle with jailer possible
+ getCastleMoves([x, y]) {
+ const c = this.getColor(x, y);
+ const firstRank = (c == "w" ? V.size.x - 1 : 0);
+ if (x != firstRank || y != this.INIT_COL_KING[c])
+ return [];
+
+ const oppCol = V.GetOppCol(c);
+ let moves = [];
+ let i = 0;
+ // King, then rook or jailer:
+ const finalSquares = [
+ [2, 3],
+ [V.size.y - 2, V.size.y - 3]
+ ];
+ castlingCheck: for (
+ let castleSide = 0;
+ castleSide < 2;
+ castleSide++
+ ) {
+ if (!this.castleFlags[c][castleSide]) continue;
+ // Rook (or jailer) and king are on initial position
+
+ const finDist = finalSquares[castleSide][0] - y;
+ let step = finDist / Math.max(1, Math.abs(finDist));
+ i = y;
+ do {
+ if (
+ this.isAttacked([x, i], [oppCol]) ||
+ (this.board[x][i] != V.EMPTY &&
+ (this.getColor(x, i) != c ||
+ ![V.KING, V.ROOK].includes(this.getPiece(x, i))))
+ ) {
+ continue castlingCheck;
+ }
+ i += step;
+ } while (i != finalSquares[castleSide][0]);
+
+ step = castleSide == 0 ? -1 : 1;
+ const rookOrJailerPos =
+ castleSide == 0
+ ? Math.min(this.INIT_COL_ROOK[c], this.INIT_COL_JAILER[c])
+ : Math.max(this.INIT_COL_ROOK[c], this.INIT_COL_JAILER[c]);
+ for (i = y + step; i != rookOrJailerPos; i += step)
+ if (this.board[x][i] != V.EMPTY) continue castlingCheck;
+
+ // Nothing on final squares, except maybe king and castling rook or jailer?
+ for (i = 0; i < 2; i++) {
+ if (
+ this.board[x][finalSquares[castleSide][i]] != V.EMPTY &&
+ this.getPiece(x, finalSquares[castleSide][i]) != V.KING &&
+ finalSquares[castleSide][i] != rookOrJailerPos
+ ) {
+ continue castlingCheck;
+ }
+ }
+
+ // If this code is reached, castle is valid
+ const castlingPiece = this.getPiece(firstRank, rookOrJailerPos);
+ moves.push(
+ new Move({
+ appear: [
+ new PiPo({ x: x, y: finalSquares[castleSide][0], p: V.KING, c: c }),
+ new PiPo({ x: x, y: finalSquares[castleSide][1], p: castlingPiece, c: c })
+ ],
+ vanish: [
+ new PiPo({ x: x, y: y, p: V.KING, c: c }),
+ new PiPo({ x: x, y: rookOrJailerPos, p: castlingPiece, c: c })
+ ],
+ end:
+ Math.abs(y - rookOrJailerPos) <= 2
+ ? { x: x, y: rookOrJailerPos }
+ : { x: x, y: y + 2 * (castleSide == 0 ? -1 : 1) }
+ })
+ );
+ }
+
+ return moves;