Fix Arena diag
[vchess.git] / client / src / variants / Pandemonium2.js
1 import { ChessRules, Move, PiPo } from "@/base_rules";
2 import { randInt } from "@/utils/alea";
3 import { ArrayFun } from "@/utils/array";
4
5 export class Pandemonium2Rules extends ChessRules {
6
7 static get PawnSpecs() {
8 return Object.assign(
9 { },
10 ChessRules.PawnSpecs,
11 { promotions: [V.GILDING] }
12 );
13 }
14
15 loseOnRepetition() {
16 // If current side is under check: lost
17 return this.underCheck(this.turn);
18 }
19
20 static get GILDING() {
21 return "g";
22 }
23
24 static get SCEPTER() {
25 return "s";
26 }
27
28 static get HORSE() {
29 return "h";
30 }
31
32 static get DRAGON() {
33 return "d";
34 }
35
36 static get CARDINAL() {
37 return "c";
38 }
39
40 static get WHOLE() {
41 return "w";
42 }
43
44 static get MARSHAL() {
45 return "m";
46 }
47
48 static get APRICOT() {
49 return "a";
50 }
51
52 static get PIECES() {
53 return (
54 ChessRules.PIECES.concat([
55 V.GILDING, V.SCEPTER, V.HORSE, V.DRAGON,
56 V.CARDINAL, V.WHOLE, V.MARSHAL, V.APRICOT])
57 );
58 }
59
60 getPpath(b) {
61 const prefix = (ChessRules.PIECES.includes(b[1]) ? "" : "Pandemonium/");
62 return prefix + b;
63 }
64
65 static get size() {
66 return { x: 8, y: 10};
67 }
68
69 getColor(i, j) {
70 if (i >= V.size.x) return i == V.size.x ? "w" : "b";
71 return this.board[i][j].charAt(0);
72 }
73
74 getPiece(i, j) {
75 if (i >= V.size.x) return V.RESERVE_PIECES[j];
76 return this.board[i][j].charAt(1);
77 }
78
79 setOtherVariables(fen) {
80 super.setOtherVariables(fen);
81 // Sub-turn is useful only at first move...
82 this.subTurn = 1;
83 // Also init reserves (used by the interface to show landable pieces)
84 const reserve =
85 V.ParseFen(fen).reserve.split("").map(x => parseInt(x, 10));
86 this.reserve = {
87 w: {
88 [V.PAWN]: reserve[0],
89 [V.ROOK]: reserve[1],
90 [V.KNIGHT]: reserve[2],
91 [V.BISHOP]: reserve[3],
92 [V.QUEEN]: reserve[4],
93 [V.CARDINAL]: reserve[5],
94 [V.MARSHAL]: reserve[6],
95 },
96 b: {
97 [V.PAWN]: reserve[7],
98 [V.ROOK]: reserve[8],
99 [V.KNIGHT]: reserve[9],
100 [V.BISHOP]: reserve[10],
101 [V.QUEEN]: reserve[11],
102 [V.CARDINAL]: reserve[12],
103 [V.MARSHAL]: reserve[13]
104 }
105 };
106 }
107
108 static IsGoodFen(fen) {
109 if (!ChessRules.IsGoodFen(fen)) return false;
110 const fenParsed = V.ParseFen(fen);
111 // Check reserves
112 if (!fenParsed.reserve || !fenParsed.reserve.match(/^[0-9]{14,14}$/))
113 return false;
114 return true;
115 }
116
117 static ParseFen(fen) {
118 const fenParts = fen.split(" ");
119 return Object.assign(
120 ChessRules.ParseFen(fen),
121 { reserve: fenParts[5] }
122 );
123 }
124
125 getFen() {
126 return super.getFen() + " " + this.getReserveFen();
127 }
128
129 getFenForRepeat() {
130 return super.getFenForRepeat() + "_" + this.getReserveFen();
131 }
132
133 getReserveFen() {
134 let counts = new Array(14);
135 for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
136 counts[i] = this.reserve["w"][V.RESERVE_PIECES[i]];
137 counts[7 + i] = this.reserve["b"][V.RESERVE_PIECES[i]];
138 }
139 return counts.join("");
140 }
141
142 static GenRandInitFen(options) {
143 if (options.randomness == 0) {
144 return (
145 "rnbqkmcbnr/pppppppppp/91/91/91/91/PPPPPPPPPP/RNBQKMCBNR " +
146 "w 0 ajaj - 00000000000000"
147 );
148 }
149
150 let pieces = { w: new Array(10), b: new Array(10) };
151 let flags = "";
152 for (let c of ["w", "b"]) {
153 if (c == 'b' && options.randomness == 1) {
154 pieces['b'] = pieces['w'];
155 flags += flags;
156 break;
157 }
158
159 let positions = ArrayFun.range(10);
160
161 // Get random squares for bishops (different colors)
162 let randIndex = 2 * randInt(5);
163 let bishop1Pos = positions[randIndex];
164 let randIndex_tmp = 2 * randInt(5) + 1;
165 let bishop2Pos = positions[randIndex_tmp];
166 positions.splice(Math.max(randIndex, randIndex_tmp), 1);
167 positions.splice(Math.min(randIndex, randIndex_tmp), 1);
168
169 randIndex = randInt(8);
170 let knight1Pos = positions[randIndex];
171 positions.splice(randIndex, 1);
172 randIndex = randInt(7);
173 let knight2Pos = positions[randIndex];
174 positions.splice(randIndex, 1);
175
176 randIndex = randInt(6);
177 let queenPos = positions[randIndex];
178 positions.splice(randIndex, 1);
179
180 // Random squares for cardinal + marshal
181 randIndex = randInt(5);
182 let cardinalPos = positions[randIndex];
183 positions.splice(randIndex, 1);
184 randIndex = randInt(4);
185 let marshalPos = positions[randIndex];
186 positions.splice(randIndex, 1);
187
188 let rook1Pos = positions[0];
189 let kingPos = positions[1];
190 let rook2Pos = positions[2];
191
192 pieces[c][rook1Pos] = "r";
193 pieces[c][knight1Pos] = "n";
194 pieces[c][bishop1Pos] = "b";
195 pieces[c][queenPos] = "q";
196 pieces[c][kingPos] = "k";
197 pieces[c][marshalPos] = "m";
198 pieces[c][cardinalPos] = "c";
199 pieces[c][bishop2Pos] = "b";
200 pieces[c][knight2Pos] = "n";
201 pieces[c][rook2Pos] = "r";
202 flags += V.CoordToColumn(rook1Pos) + V.CoordToColumn(rook2Pos);
203 }
204 return (
205 pieces["b"].join("") +
206 "/pppppppppp/91/91/91/91/91/91/PPPPPPPPPP/" +
207 pieces["w"].join("").toUpperCase() +
208 " w 0 " + flags + " - 00000000000000"
209 );
210 }
211
212 getReservePpath(index, color) {
213 const p = V.RESERVE_PIECES[index];
214 const prefix = (ChessRules.PIECES.includes(p) ? "" : "Pandemonium/");
215 return prefix + color + p;;
216 }
217
218 // Ordering on reserve pieces
219 static get RESERVE_PIECES() {
220 return (
221 [V.PAWN, V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN, V.CARDINAL, V.MARSHAL]
222 );
223 }
224
225 getReserveMoves([x, y]) {
226 const color = this.turn;
227 const oppCol = V.GetOppCol(color);
228 const p = V.RESERVE_PIECES[y];
229 if (this.reserve[color][p] == 0) return [];
230 const bounds = (p == V.PAWN ? [1, V.size.x - 1] : [0, V.size.x]);
231 let moves = [];
232 for (let i = bounds[0]; i < bounds[1]; i++) {
233 for (let j = 0; j < V.size.y; j++) {
234 if (this.board[i][j] == V.EMPTY) {
235 let mv = new Move({
236 appear: [
237 new PiPo({
238 x: i,
239 y: j,
240 c: color,
241 p: p
242 })
243 ],
244 vanish: [],
245 start: { x: x, y: y }, //a bit artificial...
246 end: { x: i, y: j }
247 });
248 if (p == V.PAWN) {
249 // Do not drop on checkmate:
250 this.play(mv);
251 const res = (
252 this.underCheck(oppCol) && !this.atLeastOneMove("noReserve")
253 );
254 this.undo(mv);
255 if (res) continue;
256 }
257 moves.push(mv);
258 }
259 }
260 }
261 return moves;
262 }
263
264 static get PromoteMap() {
265 return {
266 r: 'd',
267 n: 's',
268 b: 'h',
269 c: 'w',
270 m: 'a'
271 };
272 }
273
274 applyPromotions(moves, promoted) {
275 const lastRank = (this.turn == 'w' ? 0 : V.size.x - 1);
276 let promotions = [];
277 moves.forEach(m => {
278 if ([m.start.x, m.end.x].includes(lastRank)) {
279 let pMove = JSON.parse(JSON.stringify(m));
280 pMove.appear[0].p = promoted;
281 promotions.push(pMove);
282 }
283 });
284 Array.prototype.push.apply(moves, promotions);
285 }
286
287 getPotentialMovesFrom([x, y]) {
288 const c = this.getColor(x, y);
289 const oppCol = V.GetOppCol(c);
290 if (this.movesCount <= 1) {
291 if (this.kingPos[c][0] == x && this.kingPos[c][1] == y) {
292 // Pass (if setup is ok)
293 return [
294 new Move({
295 appear: [],
296 vanish: [],
297 start: { x: this.kingPos[c][0], y: this.kingPos[c][1] },
298 end: { x: this.kingPos[oppCol][0], y: this.kingPos[oppCol][1] }
299 })
300 ];
301 }
302 const firstRank = (this.movesCount == 0 ? V.size.x - 1 : 0);
303 if (x != firstRank || this.getPiece(x, y) != V.KNIGHT) return [];
304 // Swap with who? search for matching bishop:
305 let knights = [],
306 bishops = [];
307 for (let i = 0; i < V.size.y; i++) {
308 const elt = this.board[x][i][1];
309 if (elt == 'n') knights.push(i);
310 else if (elt == 'b') bishops.push(i);
311 }
312 const destFile = (knights[0] == y ? bishops[0] : bishops[1]);
313 return [
314 new Move({
315 appear: [
316 new PiPo({
317 x: x,
318 y: destFile,
319 c: c,
320 p: V.KNIGHT
321 }),
322 new PiPo({
323 x: x,
324 y: y,
325 c: c,
326 p: V.BISHOP
327 })
328 ],
329 vanish: [
330 new PiPo({
331 x: x,
332 y: y,
333 c: c,
334 p: V.KNIGHT
335 }),
336 new PiPo({
337 x: x,
338 y: destFile,
339 c: c,
340 p: V.BISHOP
341 })
342 ],
343 start: { x: x, y: y },
344 end: { x: x, y: destFile }
345 })
346 ];
347 }
348 // Normal move (after initial setup)
349 if (x >= V.size.x) return this.getReserveMoves([x, y]);
350 const p = this.getPiece(x, y);
351 const sq = [x, y];
352 let moves = [];
353 if (ChessRules.PIECES.includes(p))
354 moves = super.getPotentialMovesFrom(sq);
355 if ([V.GILDING, V.APRICOT, V.WHOLE].includes(p))
356 moves = super.getPotentialQueenMoves(sq);
357 switch (p) {
358 case V.SCEPTER:
359 moves = this.getPotentialScepterMoves(sq);
360 break;
361 case V.HORSE:
362 moves = this.getPotentialHorseMoves(sq);
363 break;
364 case V.DRAGON:
365 moves = this.getPotentialDragonMoves(sq);
366 break;
367 case V.CARDINAL:
368 moves = this.getPotentialCardinalMoves(sq);
369 break;
370 case V.MARSHAL:
371 moves = this.getPotentialMarshalMoves(sq);
372 break;
373 }
374 // Maybe apply promotions:
375 if (Object.keys(V.PromoteMap).includes(p))
376 this.applyPromotions(moves, V.PromoteMap[p]);
377 return moves;
378 }
379
380 getPotentialMarshalMoves(sq) {
381 return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
382 this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], 1)
383 );
384 }
385
386 getPotentialCardinalMoves(sq) {
387 return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat(
388 this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], 1)
389 );
390 }
391
392 getPotentialScepterMoves(sq) {
393 const steps =
394 V.steps[V.KNIGHT].concat(V.steps[V.BISHOP]).concat(V.steps[V.ROOK]);
395 return this.getSlideNJumpMoves(sq, steps, 1);
396 }
397
398 getPotentialHorseMoves(sq) {
399 return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat(
400 this.getSlideNJumpMoves(sq, V.steps[V.ROOK], 1));
401 }
402
403 getPotentialDragonMoves(sq) {
404 return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
405 this.getSlideNJumpMoves(sq, V.steps[V.BISHOP], 1));
406 }
407
408 getPotentialKingMoves(sq) {
409 // Initialize with normal moves
410 let moves = this.getSlideNJumpMoves(
411 sq, V.steps[V.ROOK].concat(V.steps[V.BISHOP]), 1);
412 const c = this.turn;
413 if (
414 this.castleFlags[c][0] < V.size.y ||
415 this.castleFlags[c][1] < V.size.y
416 ) {
417 const finalSquares = [
418 [1, 2],
419 [7, 6]
420 ];
421 moves = moves.concat(super.getCastleMoves(sq, finalSquares));
422 }
423 return moves;
424 }
425
426 isAttacked(sq, color) {
427 return (
428 this.isAttackedByPawn(sq, color) ||
429 this.isAttackedByRook(sq, color) ||
430 this.isAttackedByKnight(sq, color) ||
431 this.isAttackedByBishop(sq, color) ||
432 this.isAttackedByKing(sq, color) ||
433 this.isAttackedByQueens(sq, color) ||
434 this.isAttackedByScepter(sq, color) ||
435 this.isAttackedByDragon(sq, color) ||
436 this.isAttackedByHorse(sq, color) ||
437 this.isAttackedByMarshal(sq, color) ||
438 this.isAttackedByCardinal(sq, color)
439 );
440 }
441
442 isAttackedByQueens([x, y], color) {
443 // pieces: because queen = gilding = whole = apricot
444 const pieces = [V.QUEEN, V.GILDING, V.WHOLE, V.APRICOT];
445 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
446 for (let step of steps) {
447 let rx = x + step[0],
448 ry = y + step[1];
449 while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY) {
450 rx += step[0];
451 ry += step[1];
452 }
453 if (
454 V.OnBoard(rx, ry) &&
455 this.board[rx][ry] != V.EMPTY &&
456 pieces.includes(this.getPiece(rx, ry)) &&
457 this.getColor(rx, ry) == color
458 ) {
459 return true;
460 }
461 }
462 return false;
463 }
464
465 isAttackedByScepter(sq, color) {
466 const steps =
467 V.steps[V.KNIGHT].concat(V.steps[V.ROOK]).concat(V.steps[V.BISHOP]);
468 return (
469 super.isAttackedBySlideNJump(sq, color, V.SCEPTER, steps, 1)
470 );
471 }
472
473 isAttackedByHorse(sq, color) {
474 return (
475 super.isAttackedBySlideNJump(sq, color, V.HORSE, V.steps[V.BISHOP]) ||
476 super.isAttackedBySlideNJump(
477 sq, color, V.HORSE, V.steps[V.ROOK], 1)
478 );
479 }
480
481 isAttackedByDragon(sq, color) {
482 return (
483 super.isAttackedBySlideNJump(sq, color, V.DRAGON, V.steps[V.ROOK]) ||
484 super.isAttackedBySlideNJump(
485 sq, color, V.DRAGON, V.steps[V.BISHOP], 1)
486 );
487 }
488
489 isAttackedByMarshal(sq, color) {
490 return (
491 super.isAttackedBySlideNJump(sq, color, V.MARSHAL, V.steps[V.ROOK]) ||
492 super.isAttackedBySlideNJump(
493 sq, color, V.MARSHAL, V.steps[V.KNIGHT], 1)
494 );
495 }
496
497 isAttackedByCardinal(sq, color) {
498 return (
499 super.isAttackedBySlideNJump(sq, color, V.CARDINAL, V.steps[V.BISHOP]) ||
500 super.isAttackedBySlideNJump(
501 sq, color, V.CARDINAL, V.steps[V.KNIGHT], 1)
502 );
503 }
504
505 getAllValidMoves() {
506 let moves = super.getAllPotentialMoves();
507 if (this.movesCount >= 2) {
508 const color = this.turn;
509 for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
510 moves = moves.concat(
511 this.getReserveMoves([V.size.x + (color == "w" ? 0 : 1), i])
512 );
513 }
514 }
515 return this.filterValid(moves);
516 }
517
518 atLeastOneMove(noReserve) {
519 if (!super.atLeastOneMove()) {
520 if (!noReserve) {
521 // Search one reserve move
522 for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
523 let moves = this.filterValid(
524 this.getReserveMoves([V.size.x + (this.turn == "w" ? 0 : 1), i])
525 );
526 if (moves.length > 0) return true;
527 }
528 }
529 return false;
530 }
531 return true;
532 }
533
534 // Reverse 'PromoteMap'
535 static get P_CORRESPONDANCES() {
536 return {
537 d: 'r',
538 s: 'n',
539 h: 'b',
540 w: 'c',
541 a: 'm',
542 g: 'p'
543 };
544 }
545
546 static MayDecode(piece) {
547 if (Object.keys(V.P_CORRESPONDANCES).includes(piece))
548 return V.P_CORRESPONDANCES[piece];
549 return piece;
550 }
551
552 play(move) {
553 move.subTurn = this.subTurn; //much easier
554 if (this.movesCount >= 2 || this.subTurn == 2 || move.vanish.length == 0) {
555 this.turn = V.GetOppCol(this.turn);
556 this.subTurn = 1;
557 this.movesCount++;
558 }
559 else this.subTurn = 2;
560 move.flags = JSON.stringify(this.aggregateFlags());
561 this.epSquares.push(this.getEpSquare(move));
562 V.PlayOnBoard(this.board, move);
563 this.postPlay(move);
564 }
565
566 postPlay(move) {
567 if (move.vanish.length == 0 && move.appear.length == 0) return;
568 super.postPlay(move);
569 const color = move.appear[0].c;
570 if (move.vanish.length == 0)
571 // Drop unpromoted piece:
572 this.reserve[color][move.appear[0].p]--;
573 else if (move.vanish.length == 2 && move.appear.length == 1)
574 // May capture a promoted piece:
575 this.reserve[color][V.MayDecode(move.vanish[1].p)]++;
576 }
577
578 undo(move) {
579 this.epSquares.pop();
580 this.disaggregateFlags(JSON.parse(move.flags));
581 V.UndoOnBoard(this.board, move);
582 if (this.movesCount >= 2 || this.subTurn == 1 || move.vanish.length == 0) {
583 this.turn = V.GetOppCol(this.turn);
584 this.movesCount--;
585 }
586 this.subTurn = move.subTurn;
587 this.postUndo(move);
588 }
589
590 postUndo(move) {
591 if (move.vanish.length == 0 && move.appear.length == 0) return;
592 super.postUndo(move);
593 const color = move.appear[0].c;
594 if (move.vanish.length == 0)
595 this.reserve[color][move.appear[0].p]++;
596 else if (move.vanish.length == 2 && move.appear.length == 1)
597 this.reserve[color][V.MayDecode(move.vanish[1].p)]--;
598 }
599
600 static get VALUES() {
601 return Object.assign(
602 {},
603 ChessRules.VALUES,
604 {
605 n: 2.5, //knight is weaker
606 g: 9,
607 s: 5,
608 h: 6,
609 d: 7,
610 c: 7,
611 w: 9,
612 m: 8,
613 a: 9
614 }
615 );
616 }
617
618 static get SEARCH_DEPTH() {
619 return 2;
620 }
621
622 getComputerMove() {
623 if (this.movesCount <= 1) {
624 // Special case: swap and pass at random
625 const moves1 = this.getAllValidMoves();
626 const m1 = moves1[randInt(moves1.length)];
627 this.play(m1);
628 if (m1.vanish.length == 0) {
629 this.undo(m1);
630 return m1;
631 }
632 const moves2 = this.getAllValidMoves();
633 const m2 = moves2[randInt(moves2.length)];
634 this.undo(m1);
635 return [m1, m2];
636 }
637 return super.getComputerMove();
638 }
639
640 evalPosition() {
641 let evaluation = super.evalPosition();
642 // Add reserves:
643 for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
644 const p = V.RESERVE_PIECES[i];
645 evaluation += this.reserve["w"][p] * V.VALUES[p];
646 evaluation -= this.reserve["b"][p] * V.VALUES[p];
647 }
648 return evaluation;
649 }
650
651 getNotation(move) {
652 if (move.vanish.length == 0) {
653 if (move.appear.length == 0) return "pass";
654 const pieceName =
655 (move.appear[0].p == V.PAWN ? "" : move.appear[0].p.toUpperCase());
656 return pieceName + "@" + V.CoordsToSquare(move.end);
657 }
658 if (move.appear.length == 2) {
659 if (move.appear[0].p != V.KING)
660 return V.CoordsToSquare(move.start) + "S" + V.CoordsToSquare(move.end);
661 return (move.end.y < move.start.y ? "0-0" : "0-0-0");
662 }
663 let notation = super.getNotation(move);
664 if (move.vanish[0].p != V.PAWN && move.appear[0].p != move.vanish[0].p)
665 // Add promotion indication:
666 notation += "=" + move.appear[0].p.toUpperCase();
667 return notation;
668 }
669
670 };