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