import { ChessRules, Move, PiPo } from "@/base_rules";
export class Checkered1Rules extends ChessRules {
+
static board2fen(b) {
const checkered_codes = {
p: "s",
}
// Stage 1: as Checkered2. Stage 2: checkered pieces are autonomous
const stageInfo = V.ParseFen(fen).stage;
- this.stage = parseInt(stageInfo[0]);
+ this.stage = parseInt(stageInfo[0], 10);
this.sideCheckered = (this.stage == 2 ? stageInfo[1] : undefined);
}
);
}
- getPotentialMovesFrom([x, y]) {
+ getPotentialMovesFrom([x, y], noswitch) {
let standardMoves = super.getPotentialMovesFrom([x, y]);
if (this.stage == 1) {
const color = this.turn;
// King is treated differently: it never turn checkered
if (this.getPiece(x, y) == V.KING) {
// If at least one checkered piece, allow switching:
- if (this.board.some(b => b.some(cell => cell[0] == 'c'))) {
+ if (
+ !noswitch &&
+ this.board.some(b => b.some(cell => cell[0] == 'c'))
+ ) {
const oppCol = V.GetOppCol(color);
moves.push(
new Move({
)
)
) {
- const moves = this.getPotentialMovesFrom([i, j]);
+ const moves = this.getPotentialMovesFrom([i, j], "noswitch");
if (moves.length > 0) {
for (let k = 0; k < moves.length; k++)
if (this.filterValid([moves[k]]).length > 0) return true;
this.postPlay(move);
}
- updateCastleFlags(move, piece) {
- const c = V.GetOppCol(this.turn);
- const firstRank = (c == "w" ? V.size.x - 1 : 0);
- // Update castling flags if rooks are moved
- const oppCol = this.turn;
- const oppFirstRank = V.size.x - 1 - firstRank;
- if (piece == V.KING && move.appear.length > 0)
- this.castleFlags[c] = [V.size.y, V.size.y];
- else if (
- move.start.x == firstRank && //our rook moves?
- this.castleFlags[c].includes(move.start.y)
- ) {
- const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
- this.castleFlags[c][flagIdx] = V.size.y;
- }
- // NOTE: not "else if" because a rook could take an opposing rook
- if (
- move.end.x == oppFirstRank && //we took opponent rook?
- this.castleFlags[oppCol].includes(move.end.y)
- ) {
- const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1);
- this.castleFlags[oppCol][flagIdx] = V.size.y;
- }
- }
-
postPlay(move) {
if (move.appear.length == 0 && move.vanish.length == 0) {
this.stage = 2;
this.kingPos[c][0] = move.appear[0].x;
this.kingPos[c][1] = move.appear[0].y;
}
- this.updateCastleFlags(move, piece);
- // Does this move turn off a 2-squares pawn flag?
- if ([1, 6].includes(move.start.x) && move.vanish[0].p == V.PAWN)
+ super.updateCastleFlags(move, piece);
+ if (
+ [1, 6].includes(move.start.x) &&
+ move.vanish[0].p == V.PAWN &&
+ Math.abs(move.end.x - move.start.x) == 2
+ ) {
+ // This move turns off a 2-squares pawn flag
this.pawnFlags[move.start.x == 6 ? "w" : "b"][move.start.y] = false;
+ }
}
this.cmoves.push(this.getCmove(move));
}
}
static GenRandInitFen(randomness) {
- // Add 16 pawns flags + empty cmovei + stage == 1:
+ // Add 16 pawns flags + empty cmove + stage == 1:
return ChessRules.GenRandInitFen(randomness)
.slice(0, -2) + "1111111111111111 - - 1";
}
notation += "=" + move.appear[0].p.toUpperCase();
return notation;
}
+
};