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