New variant idea
[xogo.git] / variants / Checkered / class.js
CommitLineData
55d3b31f
BA
1import ChessRules from "/base_rules.js";
2import PiPo from "/utils/PiPo.js";
3import Move from "/utils/Move.js";
4
5export default class CheckeredRules extends ChessRules {
6
7 static get Options() {
8 return {
9 select: C.Options.select,
10 input: [
11 {
12 label: "Allow switching",
13 variable: "withswitch",
14 type: "checkbox",
df3fdaff 15 defaut: true
55d3b31f
BA
16 }
17 ],
55d3b31f
BA
18 styles: [
19 "balance",
20 "capture",
21 "cylinder",
22 "doublemove",
23 "madrasi",
24 "progressive",
25 "recycle",
26 "teleport"
27 ]
28 };
29 }
30
616a8d7a
BA
31 static GetColorClass(c) {
32 if (c == 'c')
33 return "checkered";
34 return C.GetColorClass(c);
35 }
36
b57b726c 37 board2fen(b) {
55d3b31f
BA
38 const checkered_codes = {
39 p: "s",
40 q: "t",
41 r: "u",
42 b: "c",
43 n: "o"
44 };
8d19ea48
BA
45 if (b[0] == "c")
46 return checkered_codes[b[1]];
55d3b31f
BA
47 return super.board2fen(b);
48 }
49
b57b726c 50 fen2board(f) {
55d3b31f
BA
51 // Tolerate upper-case versions of checkered pieces (why not?)
52 const checkered_pieces = {
53 s: "p",
54 S: "p",
55 t: "q",
56 T: "q",
57 u: "r",
58 U: "r",
59 c: "b",
60 C: "b",
61 o: "n",
62 O: "n"
63 };
64 if (Object.keys(checkered_pieces).includes(f))
65 return "c" + checkered_pieces[f];
66 return super.fen2board(f);
67 }
68
616a8d7a
BA
69 genRandInitBaseFen() {
70 let res = super.genRandInitBaseFen();
71 res.o.flags += "1".repeat(16); //pawns flags
72 return res;
73 }
74
5006aaca 75 getPartFen(o) {
ceeac4e8
BA
76 return Object.assign(
77 {
78 "cmove": o.init ? "-" : this.getCmoveFen(),
79 "stage": o.init ? "1" : this.getStageFen()
80 },
81 super.getPartFen(o)
82 );
5006aaca
BA
83 }
84
85 getCmoveFen() {
86 if (!this.cmove)
87 return "-";
88 return (
89 C.CoordsToSquare(this.cmove.start) + C.CoordsToSquare(this.cmove.end)
90 );
91 }
92
93 getStageFen() {
94 return (this.stage + this.sideCheckered);
95 }
96
97 getFlagsFen() {
98 let fen = super.getFlagsFen();
99 // Add pawns flags
ceeac4e8 100 for (let c of ["w", "b"]) {
5006aaca
BA
101 for (let i = 0; i < 8; i++)
102 fen += (this.pawnFlags[c][i] ? "1" : "0");
ceeac4e8 103 }
5006aaca
BA
104 return fen;
105 }
106
107 getPawnShift(color) {
108 return super.getPawnShift(color == 'c' ? this.turn : color);
109 }
110
ceeac4e8
BA
111 getOppCols(color) {
112 if (this.stage == 1)
113 return super.getOppCols(color).concat(['c']);
114 // Stage 2: depends if color is w+b or checkered
115 if (color == this.sideCheckered)
116 return ['w', 'b'];
117 return ['c'];
118 }
119
8d19ea48
BA
120 pieces(color, x, y) {
121 let baseRes = super.pieces(color, x, y);
b57b726c
BA
122 if (this.getPiece(x, y) == 'p' && color == 'c') {
123 const pawnShift = this.getPawnShift(this.turn); //cannot trust color
124 const initRank = (
125 (this.stage == 2 && [1, 6].includes(x)) ||
126 (this.stage == 1 &&
127 ((x == 1 && this.turn == 'b') || (x == 6 && this.turn == 'w'))
128 )
129 );
8d19ea48 130 // Checkered pawns on stage 2 are bidirectional
b57b726c
BA
131 let moveSteps = [[pawnShift, 0]],
132 attackSteps = [[pawnShift, 1], [pawnShift, -1]];
133 if (this.stage == 2) {
134 moveSteps.push([-pawnShift, 0]);
135 Array.prototype.push.apply(attackSteps,
136 [[-pawnShift, 1], [-pawnShift, -1]]);
137 }
8d19ea48
BA
138 baseRes['p'] = {
139 "class": "pawn",
140 moves: [
141 {
b57b726c 142 steps: moveSteps,
8d19ea48
BA
143 range: (initRank ? 2 : 1)
144 }
145 ],
146 attack: [
147 {
b57b726c 148 steps: attackSteps,
8d19ea48
BA
149 range: 1
150 }
151 ]
152 };
153 }
154 const checkered = {
155 's': {"class": "checkered-pawn", moveas: 'p'},
156 'u': {"class": "checkered-rook", moveas: 'r'},
157 'o': {"class": "checkered-knight", moveas: 'n'},
158 'c': {"class": "checkered-bishop", moveas: 'b'},
159 't': {"class": "checkered-queen", moveas: 'q'}
160 };
161 return Object.assign(baseRes, checkered);
162 }
55d3b31f
BA
163
164 setOtherVariables(fenParsed) {
165 super.setOtherVariables(fenParsed);
166 // Non-capturing last checkered move (if any)
167 const cmove = fenParsed.cmove;
168 if (cmove == "-") this.cmove = null;
169 else {
170 this.cmove = {
171 start: C.SquareToCoords(cmove.substr(0, 2)),
172 end: C.SquareToCoords(cmove.substr(2))
173 };
174 }
175 // Stage 1: as Checkered2. Stage 2: checkered pieces are autonomous
176 const stageInfo = fenParsed.stage;
177 this.stage = parseInt(stageInfo[0], 10);
5006aaca 178 this.sideCheckered = (this.stage == 2 ? stageInfo[1] : "");
55d3b31f
BA
179 }
180
181 setFlags(fenflags) {
182 super.setFlags(fenflags); //castleFlags
183 this.pawnFlags = {
184 w: [...Array(8)], //pawns can move 2 squares?
185 b: [...Array(8)]
186 };
187 const flags = fenflags.substr(4); //skip first 4 letters, for castle
188 for (let c of ["w", "b"]) {
189 for (let i = 0; i < 8; i++)
190 this.pawnFlags[c][i] = flags.charAt((c == "w" ? 0 : 8) + i) == "1";
191 }
192 }
193
55d3b31f
BA
194 getEpSquare(moveOrSquare) {
195 // At stage 2, all pawns can be captured en-passant
196 if (
197 this.stage == 2 ||
198 typeof moveOrSquare !== "object" ||
199 (moveOrSquare.appear.length > 0 && moveOrSquare.appear[0].c != 'c')
200 )
201 return super.getEpSquare(moveOrSquare);
202 // Checkered or switch move: no en-passant
203 return undefined;
204 }
205
206 getCmove(move) {
207 // No checkered move to undo at stage 2:
208 if (this.stage == 1 && move.vanish.length == 1 && move.appear[0].c == "c")
5006aaca 209 return {start: move.start, end: move.end};
55d3b31f
BA
210 return null;
211 }
212
213 canTake([x1, y1], [x2, y2]) {
214 const color1 = this.getColor(x1, y1);
215 const color2 = this.getColor(x2, y2);
216 if (this.stage == 2) {
217 // Black & White <-- takes --> Checkered
218 const color1 = this.getColor(x1, y1);
219 const color2 = this.getColor(x2, y2);
220 return color1 != color2 && [color1, color2].includes('c');
221 }
55d3b31f
BA
222 return (
223 color1 != color2 &&
8d19ea48 224 color2 != "c" && //checkered aren't captured
55d3b31f
BA
225 (color1 != "c" || color2 != this.turn)
226 );
227 }
228
8d19ea48 229 postProcessPotentialMoves(moves) {
df3fdaff 230 moves = super.postProcessPotentialMoves(moves);
8d19ea48
BA
231 if (this.stage == 2 || moves.length == 0)
232 return moves;
233 const color = this.turn;
234 // Apply "checkerization" of standard moves
235 const lastRank = (color == "w" ? 0 : 7);
236 const [x, y] = [moves[0].start.x, moves[0].start.y];
8d19ea48
BA
237 const piece = this.getPiece(x, y);
238 // King is treated differently: it never turn checkered
ceeac4e8 239 if (piece == 'k' && this.stage == 1) {
8d19ea48
BA
240 // If at least one checkered piece, allow switching:
241 if (
5006aaca 242 this.options["withswitch"] &&
8d19ea48
BA
243 this.board.some(b => b.some(cell => cell[0] == 'c'))
244 ) {
ceeac4e8 245 const oppKingPos = this.searchKingPos(C.GetOppTurn(this.turn))[0];
8d19ea48
BA
246 moves.push(
247 new Move({
248 start: { x: x, y: y },
ceeac4e8 249 end: {x: oppKingPos[0], y: oppKingPos[1]},
8d19ea48
BA
250 appear: [],
251 vanish: []
252 })
253 );
55d3b31f 254 }
8d19ea48
BA
255 return moves;
256 }
257 if (piece == 'p') {
258 // Filter out forbidden pawn moves
259 moves = moves.filter(m => {
ceeac4e8 260 if (m.vanish.length > 0 && m.vanish[0].p == 'p') {
55d3b31f
BA
261 if (
262 Math.abs(m.end.x - m.start.x) == 2 &&
263 !this.pawnFlags[this.turn][m.start.y]
264 ) {
8d19ea48 265 return false; //forbidden 2-squares jumps
55d3b31f
BA
266 }
267 if (
616a8d7a 268 this.board[m.end.x][m.end.y] == "" &&
55d3b31f
BA
269 m.vanish.length == 2 &&
270 this.getColor(m.start.x, m.start.y) == "c"
271 ) {
8d19ea48 272 return false; //checkered pawns cannot take en-passant
55d3b31f
BA
273 }
274 }
8d19ea48 275 return true;
55d3b31f 276 });
55d3b31f 277 }
8d19ea48
BA
278 let extraMoves = [];
279 moves.forEach(m => {
ceeac4e8 280 if (m.vanish.length == 2 && m.appear.length == 1) {
8d19ea48
BA
281 // A capture occured
282 m.appear[0].c = "c";
283 if (
284 m.appear[0].p != m.vanish[1].p &&
285 // No choice if promotion:
286 (m.vanish[0].p != 'p' || m.end.x != lastRank)
287 ) {
288 // Add transformation into captured piece
289 let m2 = JSON.parse(JSON.stringify(m));
290 m2.appear[0].p = m.vanish[1].p;
291 extraMoves.push(m2);
292 }
55d3b31f 293 }
8d19ea48
BA
294 });
295 return moves.concat(extraMoves);
55d3b31f
BA
296 }
297
ceeac4e8 298 canIplay(x, y) {
55d3b31f
BA
299 if (this.stage == 2) {
300 const color = this.getColor(x, y);
301 return (
302 this.turn == this.sideCheckered
303 ? color == 'c'
304 : ['w', 'b'].includes(color)
305 );
306 }
ceeac4e8
BA
307 return (
308 this.playerColor == this.turn &&
309 [this.turn, "c"].includes(this.getColor(x, y))
310 );
55d3b31f
BA
311 }
312
313 // Does m2 un-do m1 ? (to disallow undoing checkered moves)
314 oppositeMoves(m1, m2) {
315 return (
316 !!m1 &&
55d3b31f
BA
317 m2.appear.length == 1 &&
318 m2.vanish.length == 1 &&
5006aaca 319 m2.appear[0].c == "c" &&
55d3b31f
BA
320 m1.start.x == m2.end.x &&
321 m1.end.x == m2.start.x &&
322 m1.start.y == m2.end.y &&
323 m1.end.y == m2.start.y
324 );
325 }
326
55d3b31f 327 filterValid(moves) {
55d3b31f 328 const color = this.turn;
616a8d7a 329 if (this.stage == 2 && this.sideCheckered == color)
5006aaca
BA
330 // Checkered cannot be under check (no king)
331 return moves;
332 let kingPos = super.searchKingPos(color);
5006aaca
BA
333 if (this.stage == 2)
334 // Must consider both kings (attacked by checkered side)
df3fdaff 335 kingPos.push(super.searchKingPos(C.GetOppTurn(this.turn))[0]);
ceeac4e8 336 const oppCols = this.getOppCols(color);
b57b726c 337 const filteredMoves = moves.filter(m => {
df3fdaff
BA
338 if (m.vanish.length == 0 && m.appear.length == 0)
339 return true; //switch move
8d19ea48 340 this.playOnBoard(m);
b57b726c
BA
341 if (m.vanish[0].p == 'k')
342 kingPos[0] = [m.appear[0].x, m.appear[0].y];
55d3b31f 343 let res = true;
616a8d7a 344 if (this.stage == 1)
5006aaca
BA
345 res = !this.oppositeMoves(this.cmove, m);
346 if (res && m.appear.length > 0)
ceeac4e8 347 res = !this.underCheck(kingPos, oppCols);
b57b726c
BA
348 if (m.vanish[0].p == 'k')
349 kingPos[0] = [m.vanish[0].x, m.vanish[0].y];
5006aaca 350 this.undoOnBoard(m);
55d3b31f
BA
351 return res;
352 });
b57b726c 353 return filteredMoves;
55d3b31f
BA
354 }
355
5006aaca 356 atLeastOneMove(color) {
ceeac4e8 357 const myCols = [color, 'c'];
5006aaca
BA
358 for (let i = 0; i < this.size.x; i++) {
359 for (let j = 0; j < this.size.y; j++) {
55d3b31f
BA
360 const colIJ = this.getColor(i, j);
361 if (
5006aaca 362 this.board[i][j] != "" &&
55d3b31f 363 (
ceeac4e8 364 (this.stage == 1 && myCols.includes(colIJ)) ||
55d3b31f
BA
365 (this.stage == 2 &&
366 (
367 (this.sideCheckered == color && colIJ == 'c') ||
368 (this.sideCheckered != color && ['w', 'b'].includes(colIJ))
369 )
370 )
371 )
372 ) {
8d19ea48 373 const moves = this.getPotentialMovesFrom([i, j]);
5006aaca
BA
374 if (moves.some(m => this.filterValid([m]).length >= 1))
375 return true;
55d3b31f
BA
376 }
377 }
378 }
379 return false;
380 }
381
ceeac4e8 382 underCheck(square_s, oppCols) {
df3fdaff 383 if (this.stage == 2 && this.turn == this.sideCheckered)
5006aaca 384 return false; //checkered pieces is me, I'm not under check
df3fdaff
BA
385 // Artificial turn change required, because canTake uses turn info.
386 // canTake is called from underCheck --> ... --> findDestSquares
387 this.turn = C.GetOppTurn(this.turn);
388 const res = square_s.some(sq => super.underAttack(sq, oppCols));
389 this.turn = C.GetOppTurn(this.turn);
390 return res;
55d3b31f
BA
391 }
392
5006aaca
BA
393 prePlay(move) {
394 if (move.appear.length > 0 && move.vanish.length > 0) {
395 super.prePlay(move);
55d3b31f
BA
396 if (
397 [1, 6].includes(move.start.x) &&
616a8d7a 398 move.vanish[0].p == 'p' &&
55d3b31f
BA
399 Math.abs(move.end.x - move.start.x) == 2
400 ) {
401 // This move turns off a 2-squares pawn flag
402 this.pawnFlags[move.start.x == 6 ? "w" : "b"][move.start.y] = false;
403 }
404 }
5006aaca
BA
405 }
406
407 postPlay(move) {
408 if (move.appear.length == 0 && move.vanish.length == 0) {
409 this.stage = 2;
410 this.sideCheckered = this.turn;
df3fdaff
BA
411 if (this.playerColor != this.turn)
412 super.displayMessage(null, "Autonomous checkered!", "info-text", 2000);
5006aaca
BA
413 }
414 else
415 super.postPlay(move);
55d3b31f
BA
416 this.cmove = this.getCmove(move);
417 }
418
5006aaca
BA
419 tryChangeTurn(move) {
420 if (move.appear.length > 0 && move.vanish.length > 0)
421 super.tryChangeTurn(move);
422 }
423
55d3b31f
BA
424 getCurrentScore() {
425 const color = this.turn;
426 if (this.stage == 1) {
5006aaca
BA
427 if (this.atLeastOneMove(color))
428 return "*";
55d3b31f 429 // Artifically change turn, for checkered pawns
ceeac4e8
BA
430 const oppTurn = C.GetOppTurn(color);
431 this.turn = oppTurn;
5006aaca
BA
432 const kingPos = super.searchKingPos(color)[0];
433 let res = "1/2";
ceeac4e8 434 if (super.underAttack(kingPos, [oppTurn, 'c']))
5006aaca
BA
435 res = (color == "w" ? "0-1" : "1-0");
436 this.turn = color;
55d3b31f
BA
437 return res;
438 }
439 // Stage == 2:
5006aaca 440 if (this.sideCheckered == color) {
55d3b31f
BA
441 // Check if remaining checkered pieces: if none, I lost
442 if (this.board.some(b => b.some(cell => cell[0] == 'c'))) {
5006aaca
BA
443 if (!this.atLeastOneMove(color))
444 return "1/2";
55d3b31f
BA
445 return "*";
446 }
5006aaca 447 return (color == 'w' ? "0-1" : "1-0");
55d3b31f 448 }
5006aaca
BA
449 if (this.atLeastOneMove(color))
450 return "*";
ceeac4e8 451 let res = super.underAttack(super.searchKingPos(color)[0], ['c']);
5006aaca 452 if (!res)
ceeac4e8 453 res = super.underAttack(super.searchKingPos(oppCol)[0], ['c']);
5006aaca
BA
454 if (res)
455 return (color == 'w' ? "0-1" : "1-0");
55d3b31f
BA
456 return "1/2";
457 }
458
55d3b31f 459};