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