1 import { ChessRules
, Move
, PiPo
} from "@/base_rules";
3 export class CheckeredRules
extends ChessRules
{
5 const checkered_codes
= {
12 if (b
[0] == "c") return checkered_codes
[b
[1]];
13 return ChessRules
.board2fen(b
);
17 // Tolerate upper-case versions of checkered pieces (why not?)
18 const checkered_pieces
= {
30 if (Object
.keys(checkered_pieces
).includes(f
))
31 return "c" + checkered_pieces
[f
];
32 return ChessRules
.fen2board(f
);
36 return ChessRules
.PIECES
.concat(["s", "t", "u", "c", "o"]);
40 return (b
[0] == "c" ? "Checkered/" : "") + b
;
43 setOtherVariables(fen
) {
44 super.setOtherVariables(fen
);
45 // Local stack of non-capturing checkered moves:
47 const cmove
= V
.ParseFen(fen
).cmove
;
48 if (cmove
== "-") this.cmoves
.push(null);
51 start: ChessRules
.SquareToCoords(cmove
.substr(0, 2)),
52 end: ChessRules
.SquareToCoords(cmove
.substr(2))
57 static IsGoodFen(fen
) {
58 if (!ChessRules
.IsGoodFen(fen
)) return false;
59 const fenParts
= fen
.split(" ");
60 if (fenParts
.length
!= 6) return false;
61 if (fenParts
[5] != "-" && !fenParts
[5].match(/^([a-h][1-8]){2}$/))
66 static IsGoodFlags(flags
) {
67 // 4 for castle + 16 for pawns
68 return !!flags
.match(/^[a-z]{4,4}[01]{16,16}$/);
72 super.setFlags(fenflags
); //castleFlags
74 w: [...Array(8).fill(true)], //pawns can move 2 squares?
75 b: [...Array(8).fill(true)]
77 const flags
= fenflags
.substr(4); //skip first 4 letters, for castle
78 for (let c
of ["w", "b"]) {
79 for (let i
= 0; i
< 8; i
++)
80 this.pawnFlags
[c
][i
] = flags
.charAt((c
== "w" ? 0 : 8) + i
) == "1";
85 return [this.castleFlags
, this.pawnFlags
];
88 disaggregateFlags(flags
) {
89 this.castleFlags
= flags
[0];
90 this.pawnFlags
= flags
[1];
93 getEpSquare(moveOrSquare
) {
94 if (typeof moveOrSquare
!== "object" || moveOrSquare
.appear
[0].c
!= 'c')
95 return super.getEpSquare(moveOrSquare
);
96 // Checkered move: no en-passant
101 if (move.appear
[0].c
== "c" && move.vanish
.length
== 1)
102 return { start: move.start
, end: move.end
};
106 canTake([x1
, y1
], [x2
, y2
]) {
107 const color1
= this.getColor(x1
, y1
);
108 const color2
= this.getColor(x2
, y2
);
109 // Checkered aren't captured
113 (color1
!= "c" || color2
!= this.turn
)
117 // Post-processing: apply "checkerization" of standard moves
118 getPotentialMovesFrom([x
, y
]) {
119 let standardMoves
= super.getPotentialMovesFrom([x
, y
]);
120 const lastRank
= this.turn
== "w" ? 0 : 7;
121 // King is treated differently: it never turn checkered
122 if (this.getPiece(x
, y
) == V
.KING
) return standardMoves
;
124 standardMoves
.forEach(m
=> {
125 if (m
.vanish
[0].p
== V
.PAWN
) {
127 Math
.abs(m
.end
.x
- m
.start
.x
) == 2 &&
128 !this.pawnFlags
[this.turn
][m
.start
.y
]
130 return; //skip forbidden 2-squares jumps
133 this.board
[m
.end
.x
][m
.end
.y
] == V
.EMPTY
&&
134 m
.vanish
.length
== 2 &&
135 this.getColor(m
.start
.x
, m
.start
.y
) == "c"
137 return; //checkered pawns cannot take en-passant
140 if (m
.vanish
.length
== 1)
144 // A capture occured (m.vanish.length == 2)
148 // Avoid promotions (already treated):
149 m
.appear
[0].p
!= m
.vanish
[1].p
&&
150 (m
.vanish
[0].p
!= V
.PAWN
|| m
.end
.x
!= lastRank
)
152 // Add transformation into captured piece
153 let m2
= JSON
.parse(JSON
.stringify(m
));
154 m2
.appear
[0].p
= m
.vanish
[1].p
;
162 getPotentialPawnMoves([x
, y
]) {
163 let moves
= super.getPotentialPawnMoves([x
, y
]);
164 // Post-process: set right color for checkered moves
165 if (this.getColor(x
, y
) == 'c')
167 m
.appear
[0].c
= 'c'; //may be done twice if capture
173 canIplay(side
, [x
, y
]) {
174 return side
== this.turn
&& [side
, "c"].includes(this.getColor(x
, y
));
177 // Does m2 un-do m1 ? (to disallow undoing checkered moves)
178 oppositeMoves(m1
, m2
) {
181 m2
.appear
[0].c
== "c" &&
182 m2
.appear
.length
== 1 &&
183 m2
.vanish
.length
== 1 &&
184 m1
.start
.x
== m2
.end
.x
&&
185 m1
.end
.x
== m2
.start
.x
&&
186 m1
.start
.y
== m2
.end
.y
&&
187 m1
.end
.y
== m2
.start
.y
192 if (moves
.length
== 0) return [];
193 const color
= this.turn
;
194 const L
= this.cmoves
.length
; //at least 1: init from FEN
195 return moves
.filter(m
=> {
196 if (this.oppositeMoves(this.cmoves
[L
- 1], m
)) return false;
198 const res
= !this.underCheck(color
);
205 const oppCol
= V
.GetOppCol(this.turn
);
206 let potentialMoves
= [];
207 for (let i
= 0; i
< V
.size
.x
; i
++) {
208 for (let j
= 0; j
< V
.size
.y
; j
++) {
209 // NOTE: just testing == color isn't enough because of checkred pieces
210 if (this.board
[i
][j
] != V
.EMPTY
&& this.getColor(i
, j
) != oppCol
) {
211 Array
.prototype.push
.apply(
213 this.getPotentialMovesFrom([i
, j
])
218 return this.filterValid(potentialMoves
);
222 const oppCol
= V
.GetOppCol(this.turn
);
223 for (let i
= 0; i
< V
.size
.x
; i
++) {
224 for (let j
= 0; j
< V
.size
.y
; j
++) {
225 // NOTE: just testing == color isn't enough because of checkered pieces
226 if (this.board
[i
][j
] != V
.EMPTY
&& this.getColor(i
, j
) != oppCol
) {
227 const moves
= this.getPotentialMovesFrom([i
, j
]);
228 if (moves
.length
> 0) {
229 for (let k
= 0; k
< moves
.length
; k
++) {
230 if (this.filterValid([moves
[k
]]).length
> 0) return true;
239 // colors: array, generally 'w' and 'c' or 'b' and 'c'
240 isAttacked(sq
, colors
) {
241 if (!Array
.isArray(colors
)) colors
= [colors
];
243 this.isAttackedByPawn(sq
, colors
) ||
244 this.isAttackedByRook(sq
, colors
) ||
245 this.isAttackedByKnight(sq
, colors
) ||
246 this.isAttackedByBishop(sq
, colors
) ||
247 this.isAttackedByQueen(sq
, colors
) ||
248 this.isAttackedByKing(sq
, colors
)
252 isAttackedByPawn([x
, y
], colors
) {
253 for (let c
of colors
) {
254 const color
= (c
== "c" ? this.turn : c
);
255 let pawnShift
= color
== "w" ? 1 : -1;
256 if (x
+ pawnShift
>= 0 && x
+ pawnShift
< 8) {
257 for (let i
of [-1, 1]) {
261 this.getPiece(x
+ pawnShift
, y
+ i
) == V
.PAWN
&&
262 this.getColor(x
+ pawnShift
, y
+ i
) == c
272 isAttackedBySlideNJump([x
, y
], colors
, piece
, steps
, oneStep
) {
273 for (let step
of steps
) {
274 let rx
= x
+ step
[0],
276 while (V
.OnBoard(rx
, ry
) && this.board
[rx
][ry
] == V
.EMPTY
&& !oneStep
) {
282 this.getPiece(rx
, ry
) === piece
&&
283 colors
.includes(this.getColor(rx
, ry
))
291 isAttackedByRook(sq
, colors
) {
292 return this.isAttackedBySlideNJump(sq
, colors
, V
.ROOK
, V
.steps
[V
.ROOK
]);
295 isAttackedByKnight(sq
, colors
) {
296 return this.isAttackedBySlideNJump(
305 isAttackedByBishop(sq
, colors
) {
306 return this.isAttackedBySlideNJump(sq
, colors
, V
.BISHOP
, V
.steps
[V
.BISHOP
]);
309 isAttackedByQueen(sq
, colors
) {
310 return this.isAttackedBySlideNJump(
314 V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
])
318 isAttackedByKing(sq
, colors
) {
319 return this.isAttackedBySlideNJump(
323 V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]),
329 return this.isAttacked(this.kingPos
[color
], [V
.GetOppCol(color
), "c"]);
332 getCheckSquares(color
) {
333 // Artifically change turn, for checkered pawns
334 this.turn
= V
.GetOppCol(color
);
335 const kingAttacked
= this.isAttacked(this.kingPos
[color
], [
339 let res
= kingAttacked
340 ? [JSON
.parse(JSON
.stringify(this.kingPos
[color
]))] //need to duplicate!
347 super.postPlay(move);
348 // Does this move turn off a 2-squares pawn flag?
349 if ([1, 6].includes(move.start
.x
) && move.vanish
[0].p
== V
.PAWN
)
350 this.pawnFlags
[move.start
.x
== 6 ? "w" : "b"][move.start
.y
] = false;
351 this.cmoves
.push(this.getCmove(move));
355 super.postUndo(move);
360 if (this.atLeastOneMove()) return "*";
361 const color
= this.turn
;
362 // Artifically change turn, for checkered pawns
363 this.turn
= V
.GetOppCol(this.turn
);
364 const res
= this.isAttacked(this.kingPos
[color
], [V
.GetOppCol(color
), "c"])
369 this.turn
= V
.GetOppCol(this.turn
);
375 // Just count material for now, considering checkered neutral (...)
376 for (let i
= 0; i
< V
.size
.x
; i
++) {
377 for (let j
= 0; j
< V
.size
.y
; j
++) {
378 if (this.board
[i
][j
] != V
.EMPTY
) {
379 const sqColor
= this.getColor(i
, j
);
380 if (["w","b"].includes(sqColor
)) {
381 const sign
= sqColor
== "w" ? 1 : -1;
382 evaluation
+= sign
* V
.VALUES
[this.getPiece(i
, j
)];
390 static GenRandInitFen(randomness
) {
391 // Add 16 pawns flags + empty cmove:
392 return ChessRules
.GenRandInitFen(randomness
)
393 .slice(0, -2) + "1111111111111111 - -";
396 static ParseFen(fen
) {
397 return Object
.assign(
398 ChessRules
.ParseFen(fen
),
399 { cmove: fen
.split(" ")[5] }
404 const L
= this.cmoves
.length
;
405 const cmoveFen
= !this.cmoves
[L
- 1]
407 : ChessRules
.CoordsToSquare(this.cmoves
[L
- 1].start
) +
408 ChessRules
.CoordsToSquare(this.cmoves
[L
- 1].end
);
409 return super.getFen() + " " + cmoveFen
;
413 let fen
= super.getFlagsFen();
415 for (let c
of ["w", "b"]) {
416 for (let i
= 0; i
< 8; i
++) fen
+= this.pawnFlags
[c
][i
] ? "1" : "0";
421 static get SEARCH_DEPTH() {
426 if (move.appear
.length
== 2) {
428 if (move.end
.y
< move.start
.y
) return "0-0-0";
432 // Translate final square
433 const finalSquare
= V
.CoordsToSquare(move.end
);
435 const piece
= this.getPiece(move.start
.x
, move.start
.y
);
436 if (piece
== V
.PAWN
) {
439 if (move.vanish
.length
> 1) {
441 const startColumn
= V
.CoordToColumn(move.start
.y
);
447 move.appear
[0].p
.toUpperCase();
450 notation
= finalSquare
;
451 if (move.appear
.length
> 0 && piece
!= move.appear
[0].p
)
453 notation
+= "=" + move.appear
[0].p
.toUpperCase();
459 piece
.toUpperCase() +
460 (move.vanish
.length
> 1 ? "x" : "") +
462 (move.vanish
.length
> 1 ? "=" + move.appear
[0].p
.toUpperCase() : "")