Start thinking about Chakart
[xogo.git] / variants / Chakart / class.js
1 import ChessRules from "/base_rules";
2 import { SuicideRules } from "/variants/Suicide"; ////////:TODO generalize genRandInitFen ?!
3 // constraints satisfaction ? + Chakart display bonus messages
4 // + animation + multi-moves for bananas/bombs/mushrooms
5
6
7
8 import { ArrayFun } from "/utils/array";
9 import { randInt } from "/utils/alea";
10 import PiPo from "/utils/PiPo.js";
11 import Move from "/utils/Move.js";
12
13 export class ChakartRules extends ChessRules {
14
15 static get Options() {
16 return {
17 select: [
18 {
19 label: "Randomness",
20 variable: "randomness",
21 defaut: 2,
22 options: [
23 { label: "Deterministic", value: 0 },
24 { label: "Symmetric random", value: 1 },
25 { label: "Asymmetric random", value: 2 }
26 ]
27 }
28 ]
29 };
30 }
31
32 static get PawnSpecs() {
33 return SuicideRules.PawnSpecs;
34 }
35 get hasCastle() {
36 return false;
37 }
38 get hasEnpassant() {
39 return false;
40 }
41
42 static get IMMOBILIZE_CODE() {
43 return {
44 'p': 's',
45 'r': 'u',
46 'n': 'o',
47 'b': 'c',
48 'q': 't',
49 'k': 'l'
50 };
51 }
52
53 static get IMMOBILIZE_DECODE() {
54 return {
55 's': 'p',
56 'u': 'r',
57 'o': 'n',
58 'c': 'b',
59 't': 'q',
60 'l': 'k'
61 };
62 }
63
64 static get INVISIBLE_QUEEN() {
65 return 'i';
66 }
67
68 // Fictive color 'a', bomb banana mushroom egg
69 static get BOMB() {
70 return 'w'; //"Wario"
71 }
72 static get BANANA() {
73 return 'd'; //"Donkey"
74 }
75 static get EGG() {
76 return 'e';
77 }
78 static get MUSHROOM() {
79 return 'm';
80 }
81
82 static fen2board(f) {
83 return (
84 f.charCodeAt() <= 90
85 ? "w" + f.toLowerCase()
86 : (['w', 'd', 'e', 'm'].includes(f) ? "a" : "b") + f
87 );
88 }
89
90 static get PIECES() {
91 return (
92 ChessRules.PIECES.concat(
93 Object.keys(V.IMMOBILIZE_DECODE)).concat(
94 [V.BANANA, V.BOMB, V.EGG, V.MUSHROOM, V.INVISIBLE_QUEEN])
95 );
96 }
97
98 getPpath(b) {
99 let prefix = "";
100 if (
101 b[0] == 'a' ||
102 b[1] == V.INVISIBLE_QUEEN ||
103 Object.keys(V.IMMOBILIZE_DECODE).includes(b[1])
104 ) {
105 prefix = "Chakart/";
106 }
107 return prefix + b;
108 }
109
110 getPPpath(m) {
111 if (!!m.promoteInto) return m.promoteInto;
112 if (m.appear.length == 0 && m.vanish.length == 1)
113 // King 'remote shell capture', on an adjacent square:
114 return this.getPpath(m.vanish[0].c + m.vanish[0].p);
115 let piece = m.appear[0].p;
116 if (Object.keys(V.IMMOBILIZE_DECODE).includes(piece))
117 // Promotion by capture into immobilized piece: do not reveal!
118 piece = V.IMMOBILIZE_DECODE[piece];
119 return this.getPpath(m.appear[0].c + piece);
120 }
121
122 static ParseFen(fen) {
123 const fenParts = fen.split(" ");
124 return Object.assign(
125 ChessRules.ParseFen(fen),
126 { captured: fenParts[4] }
127 );
128 }
129
130 static IsGoodFen(fen) {
131 if (!ChessRules.IsGoodFen(fen)) return false;
132 const captured = V.ParseFen(fen).captured;
133 if (!captured || !captured.match(/^[0-9]{12,12}$/)) return false;
134 return true;
135 }
136
137 // King can be l or L (immobilized) --> similar to Alice variant
138 static IsGoodPosition(position) {
139 if (position.length == 0) return false;
140 const rows = position.split("/");
141 if (rows.length != V.size.x) return false;
142 let kings = { "k": 0, "K": 0, 'l': 0, 'L': 0 };
143 for (let row of rows) {
144 let sumElts = 0;
145 for (let i = 0; i < row.length; i++) {
146 if (['K', 'k', 'L', 'l'].includes(row[i])) kings[row[i]]++;
147 if (V.PIECES.includes(row[i].toLowerCase())) sumElts++;
148 else {
149 const num = parseInt(row[i], 10);
150 if (isNaN(num)) return false;
151 sumElts += num;
152 }
153 }
154 if (sumElts != V.size.y) return false;
155 }
156 if (kings['k'] + kings['l'] == 0 || kings['K'] + kings['L'] == 0)
157 return false;
158 return true;
159 }
160
161 static IsGoodFlags(flags) {
162 // 4 for Peach + Mario w, b
163 return !!flags.match(/^[01]{4,4}$/);
164 }
165
166 setFlags(fenflags) {
167 // King can send shell? Queen can be invisible?
168 this.powerFlags = {
169 w: { 'k': false, 'q': false },
170 b: { 'k': false, 'q': false }
171 };
172 for (let c of ["w", "b"]) {
173 for (let p of ['k', 'q']) {
174 this.powerFlags[c][p] =
175 fenflags.charAt((c == "w" ? 0 : 2) + (p == 'k' ? 0 : 1)) == "1";
176 }
177 }
178 }
179
180 aggregateFlags() {
181 return this.powerFlags;
182 }
183
184 disaggregateFlags(flags) {
185 this.powerFlags = flags;
186 }
187
188 getFen() {
189 return super.getFen() + " " + this.getCapturedFen();
190 }
191
192 getFenForRepeat() {
193 return super.getFenForRepeat() + "_" + this.getCapturedFen();
194 }
195
196 getCapturedFen() {
197 let counts = [...Array(12).fill(0)];
198 let i = 0;
199 for (let p of V.RESERVE_PIECES) {
200 counts[i] = this.captured["w"][p];
201 counts[6 + i] = this.captured["b"][p];
202 i++;
203 }
204 return counts.join("");
205 }
206
207 scanKings() {}
208
209 setOtherVariables(fen) {
210 super.setOtherVariables(fen);
211 // Initialize captured pieces' counts from FEN
212 const captured =
213 V.ParseFen(fen).captured.split("").map(x => parseInt(x, 10));
214 this.captured = {
215 w: {
216 [V.PAWN]: captured[0],
217 [V.ROOK]: captured[1],
218 [V.KNIGHT]: captured[2],
219 [V.BISHOP]: captured[3],
220 [V.QUEEN]: captured[4],
221 [V.KING]: captured[5]
222 },
223 b: {
224 [V.PAWN]: captured[6],
225 [V.ROOK]: captured[7],
226 [V.KNIGHT]: captured[8],
227 [V.BISHOP]: captured[9],
228 [V.QUEEN]: captured[10],
229 [V.KING]: captured[11]
230 }
231 };
232 this.effects = [];
233 this.subTurn = 1;
234 }
235
236 getFlagsFen() {
237 let fen = "";
238 // Add power flags
239 for (let c of ["w", "b"])
240 for (let p of ['k', 'q']) fen += (this.powerFlags[c][p] ? "1" : "0");
241 return fen;
242 }
243
244 getColor(i, j) {
245 if (i >= V.size.x) return i == V.size.x ? "w" : "b";
246 return this.board[i][j].charAt(0);
247 }
248
249 getPiece(i, j) {
250 if (i >= V.size.x) return V.RESERVE_PIECES[j];
251 return this.board[i][j].charAt(1);
252 }
253
254 getReservePpath(index, color) {
255 return color + V.RESERVE_PIECES[index];
256 }
257
258 static get RESERVE_PIECES() {
259 return [V.PAWN, V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN, V.KING];
260 }
261
262 getReserveMoves([x, y]) {
263 const color = this.turn;
264 const p = V.RESERVE_PIECES[y];
265 if (this.reserve[color][p] == 0) return [];
266 let moves = [];
267 const start = (color == 'w' && p == V.PAWN ? 1 : 0);
268 const end = (color == 'b' && p == V.PAWN ? 7 : 8);
269 for (let i = start; i < end; i++) {
270 for (let j = 0; j < V.size.y; j++) {
271 if (
272 this.board[i][j] == V.EMPTY ||
273 this.getColor(i, j) == 'a' ||
274 this.getPiece(i, j) == V.INVISIBLE_QUEEN
275 ) {
276 let m = this.getBasicMove({ p: p, x: i, y: j});
277 m.start = { x: x, y: y };
278 moves.push(m);
279 }
280 }
281 }
282 return moves;
283 }
284
285 getPotentialMovesFrom([x, y]) {
286 let moves = [];
287 if (this.subTurn == 1) {
288 moves = super.getPotentialMovesFrom([x, y]);
289 const finalPieces = V.PawnSpecs.promotions;
290 const color = this.turn;
291 const lastRank = (color == "w" ? 0 : 7);
292 let pMoves = [];
293 moves.forEach(m => {
294 if (
295 m.appear.length > 0 &&
296 ['p', 's'].includes(m.appear[0].p) &&
297 m.appear[0].x == lastRank
298 ) {
299 for (let i = 1; i < finalPieces.length; i++) {
300 const piece = finalPieces[i];
301 let otherM = JSON.parse(JSON.stringify(m));
302 otherM.appear[0].p =
303 m.appear[0].p == V.PAWN
304 ? finalPieces[i]
305 : V.IMMOBILIZE_CODE[finalPieces[i]];
306 pMoves.push(otherM);
307 }
308 // Finally alter m itself:
309 m.appear[0].p =
310 m.appear[0].p == V.PAWN
311 ? finalPieces[0]
312 : V.IMMOBILIZE_CODE[finalPieces[0]];
313 }
314 });
315 Array.prototype.push.apply(moves, pMoves);
316 }
317 else {
318 // Subturn == 2
319 const L = this.effects.length;
320 switch (this.effects[L-1]) {
321 case "kingboo":
322 // Exchange position with any visible piece,
323 // except pawns if arriving on last rank.
324 const lastRank = { 'w': 0, 'b': 7 };
325 const color = this.turn;
326 const allowLastRank = (this.getPiece(x, y) != V.PAWN);
327 for (let i=0; i<8; i++) {
328 for (let j=0; j<8; j++) {
329 const colIJ = this.getColor(i, j);
330 const pieceIJ = this.getPiece(i, j);
331 if (
332 (i != x || j != y) &&
333 this.board[i][j] != V.EMPTY &&
334 pieceIJ != V.INVISIBLE_QUEEN &&
335 colIJ != 'a'
336 ) {
337 if (
338 (pieceIJ != V.PAWN || x != lastRank[colIJ]) &&
339 (allowLastRank || i != lastRank[color])
340 ) {
341 const movedUnit = new PiPo({
342 x: x,
343 y: y,
344 c: colIJ,
345 p: this.getPiece(i, j)
346 });
347 let mMove = this.getBasicMove({ x: x, y: y }, [i, j]);
348 mMove.appear.push(movedUnit);
349 moves.push(mMove);
350 }
351 }
352 }
353 }
354 break;
355 case "toadette":
356 // Resurrect a captured piece
357 if (x >= V.size.x) moves = this.getReserveMoves([x, y]);
358 break;
359 case "daisy":
360 // Play again with any piece
361 moves = super.getPotentialMovesFrom([x, y]);
362 break;
363 }
364 }
365 return moves;
366 }
367
368 // Helper for getBasicMove(): banana/bomb effect
369 getRandomSquare([x, y], steps) {
370 const validSteps = steps.filter(s => V.OnBoard(x + s[0], y + s[1]));
371 const step = validSteps[randInt(validSteps.length)];
372 return [x + step[0], y + step[1]];
373 }
374
375 // Apply mushroom, bomb or banana effect (hidden to the player).
376 // Determine egg effect, too, and apply its first part if possible.
377 getBasicMove_aux(psq1, sq2, tr, initMove) {
378 const [x1, y1] = [psq1.x, psq1.y];
379 const color1 = this.turn;
380 const piece1 = (!!tr ? tr.p : (psq1.p || this.getPiece(x1, y1)));
381 const oppCol = V.GetOppCol(color1);
382 if (!sq2) {
383 let move = {
384 appear: [],
385 vanish: []
386 };
387 // banana or bomb defines next square, or the move ends there
388 move.appear = [
389 new PiPo({
390 x: x1,
391 y: y1,
392 c: color1,
393 p: piece1
394 })
395 ];
396 if (this.board[x1][y1] != V.EMPTY) {
397 const initP1 = this.getPiece(x1, y1);
398 move.vanish = [
399 new PiPo({
400 x: x1,
401 y: y1,
402 c: this.getColor(x1, y1),
403 p: initP1
404 })
405 ];
406 if ([V.BANANA, V.BOMB].includes(initP1)) {
407 const steps = V.steps[initP1 == V.BANANA ? V.ROOK : V.BISHOP];
408 move.next = this.getRandomSquare([x1, y1], steps);
409 }
410 }
411 move.end = { x: x1, y: y1 };
412 return move;
413 }
414 const [x2, y2] = [sq2[0], sq2[1]];
415 // The move starts normally, on board:
416 let move = super.getBasicMove([x1, y1], [x2, y2], tr);
417 if (!!tr) move.promoteInto = tr.c + tr.p; //in case of (chomped...)
418 const L = this.effects.length;
419 if (
420 [V.PAWN, V.KNIGHT].includes(piece1) &&
421 !!initMove &&
422 (this.subTurn == 1 || this.effects[L-1] == "daisy")
423 ) {
424 switch (piece1) {
425 case V.PAWN: {
426 const twoSquaresMove = (Math.abs(x2 - x1) == 2);
427 const mushroomX = x1 + (twoSquaresMove ? (x2 - x1) / 2 : 0);
428 move.appear.push(
429 new PiPo({
430 x: mushroomX,
431 y: y1,
432 c: 'a',
433 p: V.MUSHROOM
434 })
435 );
436 if (this.getColor(mushroomX, y1) == 'a') {
437 move.vanish.push(
438 new PiPo({
439 x: mushroomX,
440 y: y1,
441 c: 'a',
442 p: this.getPiece(mushroomX, y1)
443 })
444 );
445 }
446 break;
447 }
448 case V.KNIGHT: {
449 const deltaX = Math.abs(x2 - x1);
450 const deltaY = Math.abs(y2 - y1);
451 let eggSquare = [
452 x1 + (deltaX == 2 ? (x2 - x1) / 2 : 0),
453 y1 + (deltaY == 2 ? (y2 - y1) / 2 : 0)
454 ];
455 if (
456 this.board[eggSquare[0]][eggSquare[1]] != V.EMPTY &&
457 this.getColor(eggSquare[0], eggSquare[1]) != 'a'
458 ) {
459 eggSquare[0] = x1;
460 eggSquare[1] = y1;
461 }
462 move.appear.push(
463 new PiPo({
464 x: eggSquare[0],
465 y: eggSquare[1],
466 c: 'a',
467 p: V.EGG
468 })
469 );
470 if (this.getColor(eggSquare[0], eggSquare[1]) == 'a') {
471 move.vanish.push(
472 new PiPo({
473 x: eggSquare[0],
474 y: eggSquare[1],
475 c: 'a',
476 p: this.getPiece(eggSquare[0], eggSquare[1])
477 })
478 );
479 }
480 break;
481 }
482 }
483 }
484 // For (wa)luigi effect:
485 const changePieceColor = (color) => {
486 let pieces = [];
487 const oppLastRank = (color == 'w' ? 7 : 0);
488 for (let i=0; i<8; i++) {
489 for (let j=0; j<8; j++) {
490 const piece = this.getPiece(i, j);
491 if (
492 (i != move.vanish[0].x || j != move.vanish[0].y) &&
493 this.board[i][j] != V.EMPTY &&
494 piece != V.INVISIBLE_QUEEN &&
495 this.getColor(i, j) == color
496 ) {
497 if (piece != V.KING && (piece != V.PAWN || i != oppLastRank))
498 pieces.push({ x: i, y: j, p: piece });
499 }
500 }
501 }
502 // Special case of the current piece (still at its initial position)
503 if (color == color1)
504 pieces.push({ x: move.appear[0].x, y: move.appear[0].y, p: piece1 });
505 const cp = pieces[randInt(pieces.length)];
506 if (move.appear[0].x != cp.x || move.appear[0].y != cp.y) {
507 move.vanish.push(
508 new PiPo({
509 x: cp.x,
510 y: cp.y,
511 c: color,
512 p: cp.p
513 })
514 );
515 }
516 else move.appear.shift();
517 move.appear.push(
518 new PiPo({
519 x: cp.x,
520 y: cp.y,
521 c: V.GetOppCol(color),
522 p: cp.p
523 })
524 );
525 };
526 const applyEggEffect = () => {
527 if (this.subTurn == 2)
528 // No egg effects at subTurn 2
529 return;
530 // 1) Determine the effect (some may be impossible)
531 let effects = ["kingboo", "koopa", "chomp", "bowser", "daisy"];
532 if (Object.values(this.captured[color1]).some(c => c >= 1))
533 effects.push("toadette");
534 const lastRank = { 'w': 0, 'b': 7 };
535 if (
536 this.board.some((b,i) =>
537 b.some(cell => {
538 return (
539 cell[0] == oppCol &&
540 cell[1] != V.KING &&
541 (cell[1] != V.PAWN || i != lastRank[color1])
542 );
543 })
544 )
545 ) {
546 effects.push("luigi");
547 }
548 if (
549 (
550 piece1 != V.KING &&
551 (piece1 != V.PAWN || move.appear[0].x != lastRank[oppCol])
552 ) ||
553 this.board.some((b,i) =>
554 b.some(cell => {
555 return (
556 cell[0] == color1 &&
557 cell[1] != V.KING &&
558 (cell[1] != V.PAWN || i != lastRank[oppCol])
559 );
560 })
561 )
562 ) {
563 effects.push("waluigi");
564 }
565 const effect = effects[randInt(effects.length)];
566 move.end.effect = effect;
567 // 2) Apply it if possible
568 if (!(["kingboo", "toadette", "daisy"].includes(effect))) {
569 switch (effect) {
570 case "koopa":
571 move.appear = [];
572 // Maybe egg effect was applied after others,
573 // so just shift vanish array:
574 move.vanish.shift();
575 break;
576 case "chomp":
577 move.appear = [];
578 break;
579 case "bowser":
580 move.appear[0].p = V.IMMOBILIZE_CODE[piece1];
581 break;
582 case "luigi":
583 changePieceColor(oppCol);
584 break;
585 case "waluigi":
586 changePieceColor(color1);
587 break;
588 }
589 }
590 };
591 const applyMushroomEffect = () => {
592 if ([V.PAWN, V.KING, V.KNIGHT].includes(piece1)) {
593 // Just make another similar step, if possible (non-capturing)
594 const [i, j] = [
595 move.appear[0].x + (x2 - x1),
596 move.appear[0].y + (y2 - y1)
597 ];
598 if (
599 V.OnBoard(i, j) &&
600 (
601 this.board[i][j] == V.EMPTY ||
602 this.getPiece(i, j) == V.INVISIBLE_QUEEN ||
603 this.getColor(i, j) == 'a'
604 )
605 ) {
606 move.appear[0].x = i;
607 move.appear[0].y = j;
608 if (this.board[i][j] != V.EMPTY) {
609 const object = this.getPiece(i, j);
610 const color = this.getColor(i, j);
611 move.vanish.push(
612 new PiPo({
613 x: i,
614 y: j,
615 c: color,
616 p: object
617 })
618 );
619 switch (object) {
620 case V.BANANA:
621 case V.BOMB:
622 const steps = V.steps[object == V.BANANA ? V.ROOK : V.BISHOP];
623 move.next = this.getRandomSquare([i, j], steps);
624 break;
625 case V.EGG:
626 applyEggEffect();
627 break;
628 case V.MUSHROOM:
629 applyMushroomEffect();
630 break;
631 }
632 }
633 }
634 }
635 else {
636 // Queen, bishop or rook:
637 const step = [
638 (x2 - x1) / Math.abs(x2 - x1) || 0,
639 (y2 - y1) / Math.abs(y2 - y1) || 0
640 ];
641 const next = [move.appear[0].x + step[0], move.appear[0].y + step[1]];
642 if (
643 V.OnBoard(next[0], next[1]) &&
644 this.board[next[0]][next[1]] != V.EMPTY &&
645 this.getPiece(next[0], next[1]) != V.INVISIBLE_QUEEN &&
646 this.getColor(next[0], next[1]) != 'a'
647 ) {
648 const afterNext = [next[0] + step[0], next[1] + step[1]];
649 if (V.OnBoard(afterNext[0], afterNext[1])) {
650 const afterColor = this.getColor(afterNext[0], afterNext[1]);
651 if (
652 this.board[afterNext[0]][afterNext[1]] == V.EMPTY ||
653 afterColor == 'a'
654 ) {
655 move.appear[0].x = afterNext[0];
656 move.appear[0].y = afterNext[1];
657 if (this.board[afterNext[0]][afterNext[1]] != V.EMPTY) {
658 // object = banana, bomb, mushroom or egg
659 const object = this.getPiece(afterNext[0], afterNext[1]);
660 move.vanish.push(
661 new PiPo({
662 x: afterNext[0],
663 y: afterNext[1],
664 c: afterColor,
665 p: object
666 })
667 );
668 switch (object) {
669 case V.BANANA:
670 case V.BOMB:
671 const steps =
672 V.steps[object == V.BANANA ? V.ROOK : V.BISHOP];
673 move.next = this.getRandomSquare(
674 [afterNext[0], afterNext[1]], steps);
675 break;
676 case V.EGG:
677 applyEggEffect();
678 break;
679 case V.MUSHROOM:
680 applyMushroomEffect();
681 break;
682 }
683 }
684 }
685 }
686 }
687 }
688 };
689 const color2 = this.getColor(x2, y2);
690 const piece2 = this.getPiece(x2, y2);
691 if (color2 == 'a') {
692 switch (piece2) {
693 case V.BANANA:
694 case V.BOMB:
695 const steps = V.steps[piece2 == V.BANANA ? V.ROOK : V.BISHOP];
696 move.next = this.getRandomSquare([x2, y2], steps);
697 break;
698 case V.MUSHROOM:
699 applyMushroomEffect();
700 break;
701 case V.EGG:
702 if (this.subTurn == 1)
703 // No egg effect at subTurn 2
704 applyEggEffect();
705 break;
706 }
707 }
708 if (
709 this.subTurn == 1 &&
710 !move.next &&
711 move.appear.length > 0 &&
712 [V.ROOK, V.BISHOP].includes(piece1)
713 ) {
714 const finalSquare = [move.appear[0].x, move.appear[0].y];
715 if (
716 color2 != 'a' ||
717 this.getColor(finalSquare[0], finalSquare[1]) != 'a' ||
718 this.getPiece(finalSquare[0], finalSquare[1]) != V.EGG
719 ) {
720 const validSteps =
721 V.steps[piece1 == V.ROOK ? V.BISHOP : V.ROOK].filter(s => {
722 const [i, j] = [finalSquare[0] + s[0], finalSquare[1] + s[1]];
723 return (
724 V.OnBoard(i, j) &&
725 // NOTE: do not place a bomb or banana on the invisible queen!
726 (this.board[i][j] == V.EMPTY || this.getColor(i, j) == 'a')
727 );
728 });
729 if (validSteps.length >= 1) {
730 const randIdx = randInt(validSteps.length);
731 const [x, y] = [
732 finalSquare[0] + validSteps[randIdx][0],
733 finalSquare[1] + validSteps[randIdx][1]
734 ];
735 move.appear.push(
736 new PiPo({
737 x: x,
738 y: y,
739 c: 'a',
740 p: (piece1 == V.ROOK ? V.BANANA : V.BOMB)
741 })
742 );
743 if (this.board[x][y] != V.EMPTY) {
744 move.vanish.push(
745 new PiPo({ x: x, y: y, c: 'a', p: this.getPiece(x, y) }));
746 }
747 }
748 }
749 }
750 return move;
751 }
752
753 getBasicMove(psq1, sq2, tr) {
754 let moves = [];
755 if (Array.isArray(psq1)) psq1 = { x: psq1[0], y: psq1[1] };
756 let m = this.getBasicMove_aux(psq1, sq2, tr, "initMove");
757 while (!!m.next) {
758 // Last move ended on bomb or banana, direction change
759 V.PlayOnBoard(this.board, m);
760 moves.push(m);
761 m = this.getBasicMove_aux(
762 { x: m.appear[0].x, y: m.appear[0].y }, m.next);
763 }
764 for (let i=moves.length-1; i>=0; i--) V.UndoOnBoard(this.board, moves[i]);
765 moves.push(m);
766 // Now merge moves into one
767 let move = {};
768 // start is wrong for Toadette moves --> it's fixed later
769 move.start = { x: psq1.x, y: psq1.y };
770 move.end = !!sq2 ? { x: sq2[0], y: sq2[1] } : { x: psq1.x, y: psq1.y };
771 if (!!tr) move.promoteInto = moves[0].promoteInto;
772 let lm = moves[moves.length-1];
773 if (this.subTurn == 1 && !!lm.end.effect)
774 move.end.effect = lm.end.effect;
775 if (moves.length == 1) {
776 move.appear = moves[0].appear;
777 move.vanish = moves[0].vanish;
778 }
779 else {
780 // Keep first vanish and last appear (if any)
781 move.appear = lm.appear;
782 move.vanish = moves[0].vanish;
783 if (
784 move.vanish.length >= 1 &&
785 move.appear.length >= 1 &&
786 move.vanish[0].x == move.appear[0].x &&
787 move.vanish[0].y == move.appear[0].y
788 ) {
789 // Loopback on initial square:
790 move.vanish.shift();
791 move.appear.shift();
792 }
793 for (let i=1; i < moves.length - 1; i++) {
794 for (let v of moves[i].vanish) {
795 // Only vanishing objects, not appearing at init move
796 if (
797 v.c == 'a' &&
798 (
799 moves[0].appear.length == 1 ||
800 moves[0].appear[1].x != v.x ||
801 moves[0].appear[1].y != v.y
802 )
803 ) {
804 move.vanish.push(v);
805 }
806 }
807 }
808 // Final vanish is our piece, but others might be relevant
809 // (for some egg bonuses at least).
810 for (let i=1; i < lm.vanish.length; i++) {
811 if (
812 lm.vanish[i].c != 'a' ||
813 moves[0].appear.length == 1 ||
814 moves[0].appear[1].x != lm.vanish[i].x ||
815 moves[0].appear[1].y != lm.vanish[i].y
816 ) {
817 move.vanish.push(lm.vanish[i]);
818 }
819 }
820 }
821 return move;
822 }
823
824 getPotentialPawnMoves([x, y]) {
825 const color = this.turn;
826 const oppCol = V.GetOppCol(color);
827 const [sizeX, sizeY] = [V.size.x, V.size.y];
828 const shiftX = V.PawnSpecs.directions[color];
829 const firstRank = (color == "w" ? sizeX - 1 : 0);
830 let moves = [];
831 if (
832 this.board[x + shiftX][y] == V.EMPTY ||
833 this.getColor(x + shiftX, y) == 'a' ||
834 this.getPiece(x + shiftX, y) == V.INVISIBLE_QUEEN
835 ) {
836 this.addPawnMoves([x, y], [x + shiftX, y], moves);
837 if (
838 [firstRank, firstRank + shiftX].includes(x) &&
839 (
840 this.board[x + 2 * shiftX][y] == V.EMPTY ||
841 this.getColor(x + 2 * shiftX, y) == 'a' ||
842 this.getPiece(x + 2 * shiftX, y) == V.INVISIBLE_QUEEN
843 )
844 ) {
845 moves.push(this.getBasicMove({ x: x, y: y }, [x + 2 * shiftX, y]));
846 }
847 }
848 for (let shiftY of [-1, 1]) {
849 if (
850 y + shiftY >= 0 &&
851 y + shiftY < sizeY &&
852 this.board[x + shiftX][y + shiftY] != V.EMPTY &&
853 // Pawns cannot capture invisible queen this way!
854 this.getPiece(x + shiftX, y + shiftY) != V.INVISIBLE_QUEEN &&
855 ['a', oppCol].includes(this.getColor(x + shiftX, y + shiftY))
856 ) {
857 this.addPawnMoves([x, y], [x + shiftX, y + shiftY], moves);
858 }
859 }
860 return moves;
861 }
862
863 getPotentialQueenMoves(sq) {
864 const normalMoves = super.getPotentialQueenMoves(sq);
865 // If flag allows it, add 'invisible movements'
866 let invisibleMoves = [];
867 if (this.powerFlags[this.turn][V.QUEEN]) {
868 normalMoves.forEach(m => {
869 if (
870 m.appear.length == 1 &&
871 m.vanish.length == 1 &&
872 // Only simple non-capturing moves:
873 m.vanish[0].c != 'a'
874 ) {
875 let im = JSON.parse(JSON.stringify(m));
876 im.appear[0].p = V.INVISIBLE_QUEEN;
877 im.end.noHighlight = true;
878 invisibleMoves.push(im);
879 }
880 });
881 }
882 return normalMoves.concat(invisibleMoves);
883 }
884
885 getPotentialKingMoves([x, y]) {
886 let moves = super.getPotentialKingMoves([x, y]);
887 const color = this.turn;
888 // If flag allows it, add 'remote shell captures'
889 if (this.powerFlags[this.turn][V.KING]) {
890 V.steps[V.ROOK].concat(V.steps[V.BISHOP]).forEach(step => {
891 let [i, j] = [x + step[0], y + step[1]];
892 while (
893 V.OnBoard(i, j) &&
894 (
895 this.board[i][j] == V.EMPTY ||
896 this.getPiece(i, j) == V.INVISIBLE_QUEEN ||
897 (
898 this.getColor(i, j) == 'a' &&
899 [V.EGG, V.MUSHROOM].includes(this.getPiece(i, j))
900 )
901 )
902 ) {
903 i += step[0];
904 j += step[1];
905 }
906 if (V.OnBoard(i, j)) {
907 const colIJ = this.getColor(i, j);
908 if (colIJ != color) {
909 // May just destroy a bomb or banana:
910 moves.push(
911 new Move({
912 start: { x: x, y: y},
913 end: { x: i, y: j },
914 appear: [],
915 vanish: [
916 new PiPo({
917 x: i, y: j, c: colIJ, p: this.getPiece(i, j)
918 })
919 ]
920 })
921 );
922 }
923 }
924 });
925 }
926 return moves;
927 }
928
929 getSlideNJumpMoves([x, y], steps, oneStep) {
930 let moves = [];
931 outerLoop: for (let step of steps) {
932 let i = x + step[0];
933 let j = y + step[1];
934 while (
935 V.OnBoard(i, j) &&
936 (
937 this.board[i][j] == V.EMPTY ||
938 this.getPiece(i, j) == V.INVISIBLE_QUEEN ||
939 (
940 this.getColor(i, j) == 'a' &&
941 [V.EGG, V.MUSHROOM].includes(this.getPiece(i, j))
942 )
943 )
944 ) {
945 moves.push(this.getBasicMove({ x: x, y: y }, [i, j]));
946 if (oneStep) continue outerLoop;
947 i += step[0];
948 j += step[1];
949 }
950 if (V.OnBoard(i, j) && this.canTake([x, y], [i, j]))
951 moves.push(this.getBasicMove({ x: x, y: y }, [i, j]));
952 }
953 return moves;
954 }
955
956 getAllPotentialMoves() {
957 if (this.subTurn == 1) return super.getAllPotentialMoves();
958 let moves = [];
959 const color = this.turn;
960 const L = this.effects.length;
961 switch (this.effects[L-1]) {
962 case "kingboo": {
963 let allPieces = [];
964 for (let i=0; i<8; i++) {
965 for (let j=0; j<8; j++) {
966 const colIJ = this.getColor(i, j);
967 const pieceIJ = this.getPiece(i, j);
968 if (
969 i != x && j != y &&
970 this.board[i][j] != V.EMPTY &&
971 colIJ != 'a' &&
972 pieceIJ != V.INVISIBLE_QUEEN
973 ) {
974 allPieces.push({ x: i, y: j, c: colIJ, p: pieceIJ });
975 }
976 }
977 }
978 for (let x=0; x<8; x++) {
979 for (let y=0; y<8; y++) {
980 if (this.getColor(i, j) == color) {
981 // Add exchange with something
982 allPieces.forEach(pp => {
983 if (pp.x != i || pp.y != j) {
984 const movedUnit = new PiPo({
985 x: x,
986 y: y,
987 c: pp.c,
988 p: pp.p
989 });
990 let mMove = this.getBasicMove({ x: x, y: y }, [pp.x, pp.y]);
991 mMove.appear.push(movedUnit);
992 moves.push(mMove);
993 }
994 });
995 }
996 }
997 }
998 break;
999 }
1000 case "toadette": {
1001 const x = V.size.x + (this.turn == 'w' ? 0 : 1);
1002 for (let y = 0; y < 8; y++)
1003 Array.prototype.push.apply(moves, this.getReserveMoves([x, y]));
1004 break;
1005 }
1006 case "daisy":
1007 moves = super.getAllPotentialMoves();
1008 break;
1009 }
1010 return moves;
1011 }
1012
1013 play(move) {
1014 // if (!this.states) this.states = [];
1015 // const stateFen = this.getFen();
1016 // this.states.push(stateFen);
1017
1018 move.flags = JSON.stringify(this.aggregateFlags());
1019 V.PlayOnBoard(this.board, move);
1020 move.turn = [this.turn, this.subTurn];
1021 if (["kingboo", "toadette", "daisy"].includes(move.end.effect)) {
1022 this.effects.push(move.end.effect);
1023 this.subTurn = 2;
1024 }
1025 else {
1026 this.turn = V.GetOppCol(this.turn);
1027 this.movesCount++;
1028 this.subTurn = 1;
1029 }
1030 this.postPlay(move);
1031 }
1032
1033 postPlay(move) {
1034 if (move.end.effect == "toadette") this.reserve = this.captured;
1035 else this.reserve = undefined;
1036 const color = move.turn[0];
1037 if (
1038 move.vanish.length == 2 &&
1039 move.vanish[1].c != 'a' &&
1040 move.appear.length == 1 //avoid king Boo!
1041 ) {
1042 // Capture: update this.captured
1043 let capturedPiece = move.vanish[1].p;
1044 if (capturedPiece == V.INVISIBLE_QUEEN) capturedPiece = V.QUEEN;
1045 else if (Object.keys(V.IMMOBILIZE_DECODE).includes(capturedPiece))
1046 capturedPiece = V.IMMOBILIZE_DECODE[capturedPiece];
1047 this.captured[move.vanish[1].c][capturedPiece]++;
1048 }
1049 else if (move.vanish.length == 0) {
1050 if (move.appear.length == 0 || move.appear[0].c == 'a') return;
1051 // A piece is back on board
1052 this.captured[move.appear[0].c][move.appear[0].p]--;
1053 }
1054 if (move.appear.length == 0) {
1055 // Three cases: king "shell capture", Chomp or Koopa
1056 if (this.getPiece(move.start.x, move.start.y) == V.KING)
1057 // King remote capture:
1058 this.powerFlags[color][V.KING] = false;
1059 else if (move.end.effect == "chomp")
1060 this.captured[color][move.vanish[0].p]++;
1061 }
1062 else if (move.appear[0].p == V.INVISIBLE_QUEEN)
1063 this.powerFlags[move.appear[0].c][V.QUEEN] = false;
1064 if (this.subTurn == 2) return;
1065 if (
1066 move.turn[1] == 1 &&
1067 move.appear.length == 0 ||
1068 !(Object.keys(V.IMMOBILIZE_DECODE).includes(move.appear[0].p))
1069 ) {
1070 // Look for an immobilized piece of my color: it can now move
1071 for (let i=0; i<8; i++) {
1072 for (let j=0; j<8; j++) {
1073 if (this.board[i][j] != V.EMPTY) {
1074 const piece = this.getPiece(i, j);
1075 if (
1076 this.getColor(i, j) == color &&
1077 Object.keys(V.IMMOBILIZE_DECODE).includes(piece)
1078 ) {
1079 this.board[i][j] = color + V.IMMOBILIZE_DECODE[piece];
1080 move.wasImmobilized = [i, j];
1081 }
1082 }
1083 }
1084 }
1085 }
1086 // Also make opponent invisible queen visible again, if any
1087 const oppCol = V.GetOppCol(color);
1088 for (let i=0; i<8; i++) {
1089 for (let j=0; j<8; j++) {
1090 if (
1091 this.board[i][j] != V.EMPTY &&
1092 this.getColor(i, j) == oppCol &&
1093 this.getPiece(i, j) == V.INVISIBLE_QUEEN
1094 ) {
1095 this.board[i][j] = oppCol + V.QUEEN;
1096 move.wasInvisible = [i, j];
1097 }
1098 }
1099 }
1100 }
1101
1102 undo(move) {
1103 this.disaggregateFlags(JSON.parse(move.flags));
1104 V.UndoOnBoard(this.board, move);
1105 if (["kingboo", "toadette", "daisy"].includes(move.end.effect))
1106 this.effects.pop();
1107 else this.movesCount--;
1108 this.turn = move.turn[0];
1109 this.subTurn = move.turn[1];
1110 this.postUndo(move);
1111
1112 // const stateFen = this.getFen();
1113 // if (stateFen != this.states[this.states.length-1]) debugger;
1114 // this.states.pop();
1115 }
1116
1117 postUndo(move) {
1118 if (!!move.wasImmobilized) {
1119 const [i, j] = move.wasImmobilized;
1120 this.board[i][j] =
1121 this.getColor(i, j) + V.IMMOBILIZE_CODE[this.getPiece(i, j)];
1122 }
1123 if (!!move.wasInvisible) {
1124 const [i, j] = move.wasInvisible;
1125 this.board[i][j] = this.getColor(i, j) + V.INVISIBLE_QUEEN;
1126 }
1127 if (move.vanish.length == 2 && move.vanish[1].c != 'a') {
1128 let capturedPiece = move.vanish[1].p;
1129 if (capturedPiece == V.INVISIBLE_QUEEN) capturedPiece = V.QUEEN;
1130 else if (Object.keys(V.IMMOBILIZE_DECODE).includes(capturedPiece))
1131 capturedPiece = V.IMMOBILIZE_DECODE[capturedPiece];
1132 this.captured[move.vanish[1].c][capturedPiece]--;
1133 }
1134 else if (move.vanish.length == 0) {
1135 if (move.appear.length == 0 || move.appear[0].c == 'a') return;
1136 // A piece was back on board
1137 this.captured[move.appear[0].c][move.appear[0].p]++;
1138 }
1139 else if (move.appear.length == 0 && move.end.effect == "chomp")
1140 this.captured[move.vanish[0].c][move.vanish[0].p]--;
1141 if (move.vanish.length == 0) this.reserve = this.captured;
1142 else this.reserve = undefined;
1143 }
1144
1145 getCheckSquares() {
1146 return [];
1147 }
1148
1149 getCurrentScore() {
1150 // Find kings (not tracked in this variant)
1151 let kingThere = { w: false, b: false };
1152 for (let i=0; i<8; i++) {
1153 for (let j=0; j<8; j++) {
1154 if (
1155 this.board[i][j] != V.EMPTY &&
1156 ['k', 'l'].includes(this.getPiece(i, j))
1157 ) {
1158 kingThere[this.getColor(i, j)] = true;
1159 }
1160 }
1161 }
1162 if (!kingThere['w']) return "0-1";
1163 if (!kingThere['b']) return "1-0";
1164 if (!this.atLeastOneMove()) return (this.turn == 'w' ? "0-1" : "1-0");
1165 return "*";
1166 }
1167
1168 static GenRandInitFen(options) {
1169 return (
1170 SuicideRules.GenRandInitFen(options).slice(0, -1) +
1171 // Add Peach + Mario flags + capture counts
1172 "1111 000000000000"
1173 );
1174 }
1175
1176 filterValid(moves) {
1177 return moves;
1178 }
1179
1180 static get VALUES() {
1181 return Object.assign(
1182 {},
1183 ChessRules.VALUES,
1184 {
1185 s: 1,
1186 u: 5,
1187 o: 3,
1188 c: 3,
1189 t: 9,
1190 l: 1000,
1191 e: 0,
1192 d: 0,
1193 w: 0,
1194 m: 0
1195 }
1196 );
1197 }
1198
1199 static get SEARCH_DEPTH() {
1200 return 1;
1201 }
1202
1203 getComputerMove() {
1204 const moves = this.getAllValidMoves();
1205 // Split into "normal" and "random" moves:
1206 // (Next splitting condition is OK because cannot take self object
1207 // without a banana or bomb on the way).
1208 const deterministicMoves = moves.filter(m => {
1209 return m.vanish.every(a => a.c != 'a' || a.p == V.MUSHROOM);
1210 });
1211 const randomMoves = moves.filter(m => {
1212 return m.vanish.some(a => a.c == 'a' && a.p != V.MUSHROOM);
1213 });
1214 if (Math.random() < deterministicMoves.length / randomMoves.length)
1215 // Play a deterministic one: capture king or material if possible
1216 return super.getComputerMove(deterministicMoves);
1217 // Play a random effect move, at random:
1218 let move1 = randomMoves[randInt(randomMoves.length)];
1219 this.play(move1);
1220 let move2 = undefined;
1221 if (this.subTurn == 2) {
1222 const moves2 = this.getAllValidMoves();
1223 move2 = moves2[randInt(moves2.length)];
1224 }
1225 this.undo(move1);
1226 if (!move2) return move1;
1227 return [move1, move2];
1228 }
1229
1230 getNotation(move) {
1231 if (move.vanish.length == 0 && move.appear.length == 0) return "-";
1232 if (
1233 !move.end.effect &&
1234 move.appear.length > 0 &&
1235 move.appear[0].p == V.INVISIBLE_QUEEN
1236 ) {
1237 return "Q??";
1238 }
1239 const finalSquare = V.CoordsToSquare(move.end);
1240 // Next condition also includes Toadette placements:
1241 if (move.appear.length > 0 && move.vanish.every(a => a.c == 'a')) {
1242 const piece =
1243 move.appear[0].p != V.PAWN ? move.appear[0].p.toUpperCase() : "";
1244 return piece + "@" + finalSquare;
1245 }
1246 else if (move.appear.length == 0) {
1247 const piece = this.getPiece(move.start.x, move.start.y);
1248 if (piece == V.KING && !move.end.effect)
1249 // King remote capture
1250 return "Kx" + finalSquare;
1251 // Koopa or Chomp, or loopback after bananas, bombs & mushrooms:
1252 return (
1253 piece.toUpperCase() + "x" + finalSquare +
1254 (
1255 !!move.end.effect
1256 ? "*" + (move.end.effect == "koopa" ? "K" : "C")
1257 : ""
1258 )
1259 );
1260 }
1261 if (move.appear.length == 1 && move.vanish.length == 1) {
1262 const moveStart = move.appear[0].p.toUpperCase() + "@";
1263 if (move.appear[0].c == 'a' && move.vanish[0].c == 'a')
1264 // Bonus replacement:
1265 return moveStart + finalSquare;
1266 if (
1267 move.vanish[0].p == V.INVISIBLE_QUEEN &&
1268 move.appear[0].x == move.vanish[0].x &&
1269 move.appear[0].y == move.vanish[0].y
1270 ) {
1271 // Toadette takes invisible queen
1272 return moveStart + "Q" + finalSquare;
1273 }
1274 }
1275 if (
1276 move.appear.length == 2 &&
1277 move.vanish.length == 2 &&
1278 move.appear.every(a => a.c != 'a') &&
1279 move.vanish.every(v => v.c != 'a')
1280 ) {
1281 // King Boo exchange
1282 return V.CoordsToSquare(move.start) + finalSquare;
1283 }
1284 const piece = move.vanish[0].p;
1285 let notation = undefined;
1286 if (piece == V.PAWN) {
1287 // Pawn move
1288 if (this.board[move.end.x][move.end.y] != V.EMPTY) {
1289 // Capture
1290 const startColumn = V.CoordToColumn(move.start.y);
1291 notation = startColumn + "x" + finalSquare;
1292 }
1293 else notation = finalSquare;
1294 if (move.appear[0].p != V.PAWN)
1295 // Promotion
1296 notation += "=" + move.appear[0].p.toUpperCase();
1297 }
1298 else {
1299 notation =
1300 piece.toUpperCase() +
1301 (this.board[move.end.x][move.end.y] != V.EMPTY ? "x" : "") +
1302 finalSquare;
1303 }
1304 if (!!move.end.effect) {
1305 switch (move.end.effect) {
1306 case "kingboo":
1307 notation += "*B";
1308 break;
1309 case "toadette":
1310 notation += "*T";
1311 break;
1312 case "daisy":
1313 notation += "*D";
1314 break;
1315 case "bowser":
1316 notation += "*M";
1317 break;
1318 case "luigi":
1319 case "waluigi":
1320 const lastAppear = move.appear[move.appear.length - 1];
1321 const effectOn =
1322 V.CoordsToSquare({ x: lastAppear.x, y : lastAppear.y });
1323 notation += "*" + move.end.effect[0].toUpperCase() + effectOn;
1324 break;
1325 }
1326 }
1327 return notation;
1328 }
1329
1330 };