import { ChessRules, PiPo, Move } from "@/base_rules";
-export const VariantRules = class Allmate2Rules extends ChessRules {
+export class Allmate2Rules extends ChessRules {
static get HasEnpassant() {
return false;
}
}
static GenRandInitFen(randomness) {
- return ChessRules.GenRandInitFen(randomness).replace(/ -$/, "");
+ return ChessRules.GenRandInitFen(randomness).slice(0, -2);
}
getPotentialMovesFrom([x, y]) {
let attacked = {};
for (let i=0; i<V.size.x; i++) {
for (let j=0; j<V.size.y; j++) {
- if (this.getColor(i,j) == oppCol && this.isAttacked([i,j], [color]))
+ if (this.getColor(i,j) == oppCol && this.isAttacked([i,j], color))
attacked[i+"_"+j] = [i,j];
}
}
// 2) Among attacked pieces, which cannot escape capture?
- // --> without (normal-)capturing: difference with Allmate variant
+ // --> without (normal-)capturing: difference with Allmate1 variant
// Avoid "oppMoves = this.getAllValidMoves();" => infinite recursion
outerLoop: for (let i=0; i<V.size.x; i++) {
for (let j=0; j<V.size.y; j++) {
if (om.start.x == sq[0] && om.start.y == sq[1])
// Piece moved:
sq = [om.appear[0].x, om.appear[0].y];
- if (!this.isAttacked(sq, [color]))
+ if (!this.isAttacked(sq, color))
delete attacked[origSq[0]+"_"+origSq[1]];
});
V.UndoOnBoard(this.board, om);
castleSide < 2;
castleSide++ //large, then small
) {
- if (!this.castleFlags[c][castleSide]) continue;
+ if (this.castleFlags[c][castleSide] >= 8) continue;
// If this code is reached, rooks and king are on initial position
// Nothing on the path of the king ? (and no checks)
// Nothing on the path to the rook?
step = castleSide == 0 ? -1 : 1;
- for (i = y + step; i != this.INIT_COL_ROOK[c][castleSide]; i += step) {
+ const rookPos = this.castleFlags[c][castleSide];
+ for (i = y + step; i != rookPos; i += step) {
if (this.board[x][i] != V.EMPTY) continue castlingCheck;
}
- const rookPos = this.INIT_COL_ROOK[c][castleSide];
// Nothing on final squares, except maybe king and castling rook?
for (i = 0; i < 2; i++) {
if (em.start.x == attacked[0] && em.start.y == attacked[1])
// King moved:
sq = [em.appear[0].x, em.appear[0].y];
- if (!this.isAttacked(sq, [oppCol]))
+ if (!this.isAttacked(sq, oppCol))
res = true;
V.UndoOnBoard(this.board, em);
if (res)
});
}
- updateVariables(move) {
- super.updateVariables(move);
- const color = V.GetOppCol(this.turn);
+ postPlay(move) {
+ super.postPlay(move);
if (move.vanish.length >= 2 && move.appear.length == 1) {
- move.vanish.forEach(v => {
- if (v.c == color)
- return;
+ for (let i = 1; i<move.vanish.length; i++) {
+ const v = move.vanish[i];
// Did opponent king disappeared?
if (v.p == V.KING)
this.kingPos[this.turn] = [-1, -1];
// Or maybe a rook?
else if (v.p == V.ROOK) {
if (v.y < this.INIT_COL_KING[v.c])
- this.castleFlags[v.c][0] = false;
+ this.castleFlags[v.c][0] = 8;
else
// v.y > this.INIT_COL_KING[v.c]
- this.castleFlags[v.c][1] = false;
+ this.castleFlags[v.c][1] = 8;
}
- });
+ }
}
}
- unupdateVariables(move) {
- super.unupdateVariables(move);
- const color = this.turn;
+ preUndo(move) {
+ super.preUndo(move);
+ const oppCol = this.turn;
if (move.vanish.length >= 2 && move.appear.length == 1) {
// Did opponent king disappeared?
- const psq = move.vanish.find(v => v.p == V.KING && v.c != color)
+ const psq = move.vanish.find(v => v.p == V.KING && v.c == oppCol)
if (psq)
this.kingPos[psq.c] = [psq.x, psq.y];
}
}
static get SEARCH_DEPTH() {
- return 2;
+ return 1;
}
getNotation(move) {