variants/Chakart/class.js

   1 import ChessRules from "/base_rules.js";
   2 import GiveawayRules from "/variants/Giveaway/class.js";
   3 import { ArrayFun } from "/utils/array.js";
   4 import { Random } from "/utils/alea.js";
   5 import PiPo from "/utils/PiPo.js";
   6 import Move from "/utils/Move.js";
   7
   8 export default class ChakartRules extends ChessRules {
   9
  10   static get Options() {
  11     return {
  12       select: [
  13         {
  14           label: "Randomness",
  15           variable: "randomness",
  16           defaut: 2,
  17           options: [
  18             {label: "Deterministic", value: 0},
  19             {label: "Symmetric random", value: 1},
  20             {label: "Asymmetric random", value: 2}
  21           ]
  22         }
  23       ],
  24       styles: ["cylinder"]
  25     };
  26   }
  27
  28   get pawnPromotions() {
  29     return ['q', 'r', 'n', 'b', 'k'];
  30   }
  31
  32   get hasCastle() {
  33     return false;
  34   }
  35   get hasEnpassant() {
  36     return false;
  37   }
  38   get hasReserve() {
  39     return true;
  40   }
  41   get hasReserveFen() {
  42     return false;
  43   }
  44
  45   static get IMMOBILIZE_CODE() {
  46     return {
  47       'p': 's',
  48       'r': 'u',
  49       'n': 'o',
  50       'b': 'c',
  51       'q': 't',
  52       'k': 'l'
  53     };
  54   }
  55
  56   static get IMMOBILIZE_DECODE() {
  57     return {
  58       's': 'p',
  59       'u': 'r',
  60       'o': 'n',
  61       'c': 'b',
  62       't': 'q',
  63       'l': 'k'
  64     };
  65   }
  66
  67   // Fictive color 'a', bomb banana mushroom egg
  68   static get BOMB() {
  69     return 'w'; //"Wario"
  70   }
  71   static get BANANA() {
  72     return 'd'; //"Donkey"
  73   }
  74   static get EGG() {
  75     return 'e';
  76   }
  77   static get MUSHROOM() {
  78     return 'm';
  79   }
  80
  81   static get EGG_SURPRISE() {
  82     return [
  83       "kingboo", "bowser", "daisy", "koopa",
  84       "luigi", "waluigi", "toadette", "chomp"];
  85   }
  86
  87   canIplay(x, y) {
  88     if (
  89       this.playerColor != this.turn ||
  90       Object.keys(V.IMMOBILIZE_DECODE).includes(this.getPiece(x, y))
  91     ) {
  92       return false;
  93     }
  94     return this.egg == "kingboo" || this.getColor(x, y) == this.turn;
  95   }
  96
  97   pieces(color, x, y) {
  98     const specials = {
  99       'i': {"class": "invisible"}, //queen
 100       '?': {"class": "mystery"}, //...initial square
 101       'e': {"class": "egg"},
 102       'm': {"class": "mushroom"},
 103       'd': {"class": "banana"},
 104       'w': {"class": "bomb"},
 105       'z': {"class": "remote-capture"}
 106     };
 107     const bowsered = {
 108       's': {"class": ["immobilized", "pawn"]},
 109       'u': {"class": ["immobilized", "rook"]},
 110       'o': {"class": ["immobilized", "knight"]},
 111       'c': {"class": ["immobilized", "bishop"]},
 112       't': {"class": ["immobilized", "queen"]},
 113       'l': {"class": ["immobilized", "king"]}
 114     };
 115     return Object.assign(
 116       {
 117         'y': {
 118           // Virtual piece for "king remote shell captures"
 119           moves: [],
 120           attack: [
 121             {
 122               steps: [
 123                 [0, 1], [0, -1], [1, 0], [-1, 0],
 124                 [1, 1], [1, -1], [-1, 1], [-1, -1]
 125               ]
 126             }
 127           ]
 128         }
 129       },
 130       specials, bowsered, super.pieces(color, x, y)
 131     );
 132   }
 133
 134   genRandInitFen(seed) {
 135     const options = Object.assign({mode: "suicide"}, this.options);
 136     const gr = new GiveawayRules({options: options, genFenOnly: true});
 137     const baseFen = gr.genRandInitFen(seed);
 138     const fenParts = baseFen.split(" ");
 139     let others = JSON.parse(fenParts[3]);
 140     delete others["enpassant"];
 141     others["flags"] = "1111"; //Peach + Mario flags
 142     return fenParts.slice(0, 3).join(" ") + " " + JSON.stringify(others);
 143   }
 144
 145   fen2board(f) {
 146     return (
 147       f.charCodeAt() <= 90
 148         ? "w" + f.toLowerCase()
 149         : (['w', 'd', 'e', 'm'].includes(f) ? "a" : "b") + f
 150     );
 151   }
 152
 153   setFlags(fenflags) {
 154     // King can send shell? Queen can be invisible?
 155     this.powerFlags = {
 156       w: {k: false, q: false},
 157       b: {k: false, q: false}
 158     };
 159     for (let c of ['w', 'b']) {
 160       for (let p of ['k', 'q']) {
 161         this.powerFlags[c][p] =
 162           fenflags.charAt((c == "w" ? 0 : 2) + (p == 'k' ? 0 : 1)) == "1";
 163       }
 164     }
 165   }
 166
 167   aggregateFlags() {
 168     return this.powerFlags;
 169   }
 170
 171   disaggregateFlags(flags) {
 172     this.powerFlags = flags;
 173   }
 174
 175   getFlagsFen() {
 176     return ['w', 'b'].map(c => {
 177       return ['k', 'q'].map(p => this.powerFlags[c][p] ? "1" : "0").join("");
 178     }).join("");
 179   }
 180
 181   setOtherVariables(fenParsed) {
 182     super.setOtherVariables(fenParsed);
 183     this.egg = null;
 184     // Change seed (after FEN generation!!)
 185     // so that further calls differ between players:
 186     Random.setSeed(Math.floor(19840 * Math.random()));
 187   }
 188
 189   initReserves() {
 190     this.reserve = {}; //to be filled later
 191   }
 192
 193   canStepOver(i, j) {
 194     return (
 195       this.board[i][j] == "" ||
 196       ['i', V.EGG, V.MUSHROOM].includes(this.getPiece(i, j))
 197     );
 198   }
 199
 200   // For Toadette bonus
 201   canDrop([c, p], [i, j]) {
 202     return (
 203       (
 204         this.board[i][j] == "" ||
 205         this.getColor(i, j) == 'a' ||
 206         this.getPiece(i, j) == 'i'
 207       )
 208       &&
 209       (p != "p" || (c == 'w' && i < this.size.x - 1) || (c == 'b' && i > 0))
 210     );
 211   }
 212
 213   getPotentialMovesFrom([x, y]) {
 214     let moves = [];
 215     const piece = this.getPiece(x, y);
 216     if (this.egg == "toadette")
 217       moves = this.getDropMovesFrom([x, y]);
 218     else if (this.egg == "kingboo") {
 219       const color = this.turn;
 220       const oppCol = C.GetOppCol(color);
 221       // Only allow to swap (non-immobilized!) pieces
 222       for (let i=0; i<this.size.x; i++) {
 223         for (let j=0; j<this.size.y; j++) {
 224           const colIJ = this.getColor(i, j);
 225           const pieceIJ = this.getPiece(i, j);
 226           if (
 227             (i != x || j != y) &&
 228             ['w', 'b'].includes(colIJ) &&
 229             !Object.keys(V.IMMOBILIZE_DECODE).includes(pieceIJ) &&
 230             // Next conditions = no pawn on last rank
 231             (
 232               piece != 'p' ||
 233               (
 234                 (color != 'w' || i != 0) &&
 235                 (color != 'b' || i != this.size.x - 1)
 236               )
 237             )
 238             &&
 239             (
 240               pieceIJ != 'p' ||
 241               (
 242                 (colIJ != 'w' || x != 0) &&
 243                 (colIJ != 'b' || x != this.size.x - 1)
 244               )
 245             )
 246           ) {
 247             let m = this.getBasicMove([x, y], [i, j]);
 248             m.appear.push(new PiPo({x: x, y: y, p: pieceIJ, c: colIJ}));
 249             m.kingboo = true; //avoid some side effects (bananas/bombs)
 250             moves.push(m);
 251           }
 252         }
 253       }
 254     }
 255     else {
 256       // Normal case (including bonus daisy)
 257       switch (piece) {
 258         case 'p':
 259           moves = this.getPawnMovesFrom([x, y]); //apply promotions
 260           break;
 261         case 'q':
 262           moves = this.getQueenMovesFrom([x, y]);
 263           break;
 264         case 'k':
 265           moves = this.getKingMovesFrom([x, y]);
 266           break;
 267         case 'n':
 268           moves = this.getKnightMovesFrom([x, y]);
 269           break;
 270         case 'b':
 271         case 'r':
 272           // Explicitely listing types to avoid moving immobilized piece
 273           moves = super.getPotentialMovesOf(piece, [x, y]);
 274           break;
 275       }
 276     }
 277     return moves;
 278   }
 279
 280   getPawnMovesFrom([x, y]) {
 281     const color = this.turn;
 282     const oppCol = C.GetOppCol(color);
 283     const shiftX = (color == 'w' ? -1 : 1);
 284     const firstRank = (color == "w" ? this.size.x - 1 : 0);
 285     let moves = [];
 286     const frontPiece = this.getPiece(x + shiftX, y);
 287     if (
 288       this.board[x + shiftX][y] == "" ||
 289       this.getColor(x + shiftX, y) == 'a' ||
 290       frontPiece == 'i'
 291     ) {
 292       moves.push(this.getBasicMove([x, y], [x + shiftX, y]));
 293       if (
 294         [firstRank, firstRank + shiftX].includes(x) &&
 295         ![V.BANANA, V.BOMB].includes(frontPiece) &&
 296         (
 297           this.board[x + 2 * shiftX][y] == "" ||
 298           this.getColor(x + 2 * shiftX, y) == 'a' ||
 299           this.getPiece(x + 2 * shiftX, y) == 'i'
 300         )
 301       ) {
 302         moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
 303       }
 304     }
 305     for (let shiftY of [-1, 1]) {
 306       const nextY = this.getY(y + shiftY);
 307       if (
 308         nextY >= 0 &&
 309         nextY < this.size.y &&
 310         this.board[x + shiftX][nextY] != "" &&
 311         // Pawns cannot capture invisible queen this way!
 312         this.getPiece(x + shiftX, nextY) != 'i' &&
 313         ['a', oppCol].includes(this.getColor(x + shiftX, nextY))
 314       ) {
 315         moves.push(this.getBasicMove([x, y], [x + shiftX, nextY]));
 316       }
 317     }
 318     this.pawnPostProcess(moves, color, oppCol);
 319     // Add mushroom on before-last square (+ potential segments)
 320     moves.forEach(m => {
 321       let [mx, my] = [x, y];
 322       if (Math.abs(m.end.x - m.start.x) == 2)
 323         mx = (m.start.x + m.end.x) / 2;
 324       m.appear.push(new PiPo({x: mx, y: my, c: 'a', p: 'm'}));
 325       if (mx != x && this.board[mx][my] != "") {
 326         m.vanish.push(new PiPo({
 327           x: mx,
 328           y: my,
 329           c: this.getColor(mx, my),
 330           p: this.getPiece(mx, my)
 331         }));
 332       }
 333       if (Math.abs(m.end.y - m.start.y) > 1) {
 334         m.segments = [
 335           [[x, y], [x, y]],
 336           [[m.end.x, m.end.y], [m.end.x, m.end.y]]
 337         ];
 338       }
 339     });
 340     return moves;
 341   }
 342
 343   getKnightMovesFrom([x, y]) {
 344     // Add egg on initial square:
 345     return super.getPotentialMovesOf('n', [x, y]).map(m => {
 346       m.appear.push(new PiPo({p: "e", c: "a", x: x, y: y}));
 347       return m;
 348     });
 349   }
 350
 351   getQueenMovesFrom(sq) {
 352     const normalMoves = super.getPotentialMovesOf('q', sq);
 353     // If flag allows it, add 'invisible movements'
 354     let invisibleMoves = [];
 355     if (this.powerFlags[this.turn]['q']) {
 356       normalMoves.forEach(m => {
 357         if (
 358           m.appear.length == 1 &&
 359           m.vanish.length == 1 &&
 360           // Only simple non-capturing moves:
 361           m.vanish[0].c != 'a'
 362         ) {
 363           let im = JSON.parse(JSON.stringify(m));
 364           im.appear[0].p = 'i';
 365           im.noAnimate = true;
 366           invisibleMoves.push(im);
 367         }
 368       });
 369     }
 370     return normalMoves.concat(invisibleMoves);
 371   }
 372
 373   getKingMovesFrom([x, y]) {
 374     let moves = super.getPotentialMovesOf('k', [x, y]);
 375     // If flag allows it, add 'remote shell captures'
 376     if (this.powerFlags[this.turn]['k']) {
 377       let shellCaptures = super.getPotentialMovesOf('y', [x, y]);
 378       shellCaptures.forEach(sc => {
 379         sc.shell = true; //easier play()
 380         sc.choice = 'z'; //to display in showChoices()
 381         // Fix move (Rifle style):
 382         sc.vanish.shift();
 383         sc.appear.shift();
 384       });
 385       Array.prototype.push.apply(moves, shellCaptures);
 386     }
 387     return moves;
 388   }
 389
 390   play(move) {
 391     const color = this.turn;
 392     const oppCol = C.GetOppCol(color);
 393     if (
 394       move.appear.length > 0 &&
 395       move.appear[0].p == 'p' &&
 396       (
 397         (color == 'w' && move.end.x == 0) ||
 398         (color == 'b' && move.end.x == this.size.x - 1)
 399       )
 400     ) {
 401       // "Forgotten" promotion, which occurred after some effect
 402       let moves = [move];
 403       super.pawnPostProcess(moves, color, oppCol);
 404       super.showChoices(moves);
 405       return false;
 406     }
 407     this.postPlay(move, color, oppCol);
 408     return true;
 409   }
 410
 411   postPlay(move, color, oppCol) {
 412     this.egg = move.egg;
 413     if (move.egg == "toadette") {
 414       this.reserve = { w: {}, b: {} };
 415       // Randomly select a piece in pawnPromotions
 416       if (!move.toadette)
 417         move.toadette = Random.sample(this.pawnPromotions);
 418       this.reserve[color][move.toadette] = 1;
 419       this.re_drawReserve([color]);
 420     }
 421     else if (Object.keys(this.reserve).length > 0) {
 422       this.reserve = {};
 423       this.re_drawReserve([color]);
 424     }
 425     if (move.shell)
 426       this.powerFlags[color]['k'] = false;
 427     else if (move.appear.length > 0 && move.appear[0].p == 'i') {
 428       this.powerFlags[move.appear[0].c]['q'] = false;
 429       if (color == this.playerColor) {
 430         move.appear.push(
 431           new PiPo({x: move.start.x, y: move.start.y, c: color, p: '?'}));
 432       }
 433     }
 434     if (color == this.playerColor) {
 435       // Look for an immobilized piece of my color: it can now move
 436       for (let i=0; i<8; i++) {
 437         for (let j=0; j<8; j++) {
 438           if ((i != move.end.x || j != move.end.y) && this.board[i][j] != "") {
 439             const piece = this.getPiece(i, j);
 440             if (
 441               this.getColor(i, j) == color &&
 442               Object.keys(V.IMMOBILIZE_DECODE).includes(piece)
 443             ) {
 444               move.vanish.push(new PiPo({
 445                 x: i, y: j, c: color, p: piece
 446               }));
 447               move.appear.push(new PiPo({
 448                 x: i, y: j, c: color, p: V.IMMOBILIZE_DECODE[piece]
 449               }));
 450             }
 451           }
 452         }
 453       }
 454       // Also make opponent invisible queen visible again, if any
 455       for (let i=0; i<8; i++) {
 456         for (let j=0; j<8; j++) {
 457           if (
 458             this.board[i][j] != "" &&
 459             this.getColor(i, j) == oppCol
 460           ) {
 461             const pieceIJ = this.getPiece(i, j);
 462             if (
 463               pieceIJ == 'i' &&
 464               // Ensure that current move doesn't erase invisible queen
 465               move.appear.every(a => a.x != i || a.y != j)
 466             ) {
 467               move.vanish.push(new PiPo({x: i, y: j, c: oppCol, p: 'i'}));
 468               move.appear.push(new PiPo({x: i, y: j, c: oppCol, p: 'q'}));
 469             }
 470             else if (pieceIJ == '?')
 471               move.vanish.push(new PiPo({x: i, y: j, c: oppCol, p: '?'}));
 472           }
 473         }
 474       }
 475     }
 476     this.playOnBoard(move);
 477     super.postPlay(move);
 478   }
 479
 480   playVisual(move, r) {
 481     super.playVisual(move, r);
 482     if (move.egg)
 483       this.displayBonus(move);
 484   }
 485
 486   computeNextMove(move) {
 487     // Set potential random effects, so that play() is deterministic
 488     // from opponent viewpoint:
 489     const endPiece = this.getPiece(move.end.x, move.end.y);
 490     switch (endPiece) {
 491       case V.EGG:
 492         move.egg = Random.sample(V.EGG_SURPRISE);
 493         move.next = this.getEggEffect(move);
 494         break;
 495       case V.MUSHROOM:
 496         move.next = this.getMushroomEffect(move);
 497         break;
 498       case V.BANANA:
 499       case V.BOMB:
 500         move.next = this.getBombBananaEffect(move, endPiece);
 501         break;
 502     }
 503     // NOTE: Chakart has also some side-effects:
 504     if (
 505       !move.next && move.appear.length > 0 &&
 506       !move.kingboo && !move.luigiEffect
 507     ) {
 508       const movingPiece = move.appear[0].p;
 509       if (['b', 'r'].includes(movingPiece)) {
 510         // Drop a banana or bomb:
 511         const bs =
 512           this.getRandomSquare([move.end.x, move.end.y],
 513             movingPiece == 'r'
 514               ? [[1, 1], [1, -1], [-1, 1], [-1, -1]]
 515               : [[1, 0], [-1, 0], [0, 1], [0, -1]],
 516             "freeSquare");
 517         if (bs) {
 518           move.appear.push(
 519             new PiPo({
 520               x: bs[0],
 521               y: bs[1],
 522               c: 'a',
 523               p: movingPiece == 'r' ? 'd' : 'w'
 524             })
 525           );
 526           if (this.board[bs[0]][bs[1]] != "") {
 527             move.vanish.push(
 528               new PiPo({
 529                 x: bs[0],
 530                 y: bs[1],
 531                 c: this.getColor(bs[0], bs[1]),
 532                 p: this.getPiece(bs[0], bs[1])
 533               })
 534             );
 535           }
 536         }
 537       }
 538     }
 539   }
 540
 541   isLastMove(move) {
 542     return !move.next && !["daisy", "toadette", "kingboo"].includes(move.egg);
 543   }
 544
 545   // Helper to set and apply banana/bomb effect
 546   getRandomSquare([x, y], steps, freeSquare) {
 547     let validSteps = steps.filter(s => this.onBoard(x + s[0], y + s[1]));
 548     if (freeSquare) {
 549       // Square to put banana/bomb cannot be occupied by a piece
 550       validSteps = validSteps.filter(s => {
 551         return ["", 'a'].includes(this.getColor(x + s[0], y + s[1]))
 552       });
 553     }
 554     if (validSteps.length == 0)
 555       return null;
 556     const step = validSteps[Random.randInt(validSteps.length)];
 557     return [x + step[0], y + step[1]];
 558   }
 559
 560   getEggEffect(move) {
 561     const getRandomPiece = (c) => {
 562       let bagOfPieces = [];
 563       for (let i=0; i<this.size.x; i++) {
 564         for (let j=0; j<this.size.y; j++) {
 565           if (this.getColor(i, j) == c && this.getPiece(i, j) != 'k')
 566             bagOfPieces.push([i, j]);
 567         }
 568       }
 569       if (bagOfPieces.length >= 1)
 570         return Random.sample(bagOfPieces);
 571       return null;
 572     };
 573     const color = this.turn;
 574     let em = null;
 575     switch (move.egg) {
 576       case "luigi":
 577       case "waluigi":
 578         // Change color of friendly or enemy piece, king excepted
 579         const oldColor = (move.egg == "waluigi" ? color : C.GetOppCol(color));
 580         const newColor = C.GetOppCol(oldColor);
 581         const coords = getRandomPiece(oldColor);
 582         if (coords) {
 583           const piece = this.getPiece(coords[0], coords[1]);
 584           em = new Move({
 585             appear: [
 586               new PiPo({x: coords[0], y: coords[1], c: newColor, p: piece})
 587             ],
 588             vanish: [
 589               new PiPo({x: coords[0], y: coords[1], c: oldColor, p: piece})
 590             ]
 591           });
 592           em.luigiEffect = true; //avoid dropping bomb/banana by mistake
 593         }
 594         break;
 595       case "bowser":
 596         em = new Move({
 597           appear: [
 598             new PiPo({
 599               x: move.end.x,
 600               y: move.end.y,
 601               c: color,
 602               p: V.IMMOBILIZE_CODE[move.appear[0].p]
 603             })
 604           ],
 605           vanish: [
 606             new PiPo({
 607               x: move.end.x,
 608               y: move.end.y,
 609               c: color,
 610               p: move.appear[0].p
 611             })
 612           ]
 613         });
 614         break;
 615       case "koopa":
 616         // Reverse move
 617         em = new Move({
 618           appear: [
 619             new PiPo({
 620               x: move.start.x, y: move.start.y, c: color, p: move.appear[0].p
 621             })
 622           ],
 623           vanish: [
 624             new PiPo({
 625               x: move.end.x, y: move.end.y, c: color, p: move.appear[0].p
 626             })
 627           ]
 628         });
 629         if (this.board[move.start.x][move.start.y] != "") {
 630           // Pawn or knight let something on init square
 631           em.vanish.push(new PiPo({
 632             x: move.start.x,
 633             y: move.start.y,
 634             c: 'a',
 635             p: this.getPiece(move.start.x, move.start.y)
 636           }));
 637         }
 638         break;
 639       case "chomp":
 640         // Eat piece
 641         em = new Move({
 642           appear: [],
 643           vanish: [
 644             new PiPo({
 645               x: move.end.x, y: move.end.y, c: color, p: move.appear[0].p
 646             })
 647           ],
 648           end: {x: move.end.x, y: move.end.y}
 649         });
 650         break;
 651     }
 652     if (em && move.egg != "koopa")
 653       em.noAnimate = true; //static move
 654     return em;
 655   }
 656
 657   getMushroomEffect(move) {
 658     if (
 659       typeof move.start.x == "string" || //drop move (toadette)
 660       ['b', 'r', 'q'].includes(move.vanish[0].p) //slider
 661     ) {
 662       return null;
 663     }
 664     let step = [move.end.x - move.start.x, move.end.y - move.start.y];
 665     if (Math.abs(step[0]) == 2 && Math.abs(step[1]) == 0)
 666       // Pawn initial 2-squares move: normalize step
 667       step[0] /= 2;
 668     const nextSquare = [move.end.x + step[0], move.end.y + step[1]];
 669     let nextMove = null;
 670     if (
 671       this.onBoard(nextSquare[0], nextSquare[1]) &&
 672       (
 673         this.board[nextSquare[0]][nextSquare[1]] == "" ||
 674         this.getColor(nextSquare[0], nextSquare[1]) == 'a'
 675       )
 676     ) {
 677       this.playOnBoard(move); //HACK for getBasicMove()
 678       nextMove = this.getBasicMove([move.end.x, move.end.y], nextSquare);
 679       this.undoOnBoard(move);
 680     }
 681     return nextMove;
 682   }
 683
 684   getBombBananaEffect(move, item) {
 685     const steps = item == V.BANANA
 686       ? [[1, 0], [-1, 0], [0, 1], [0, -1]]
 687       : [[1, 1], [1, -1], [-1, 1], [-1, -1]];
 688     const nextSquare = this.getRandomSquare([move.end.x, move.end.y], steps);
 689     this.playOnBoard(move); //HACK for getBasicMove()
 690     const res = this.getBasicMove([move.end.x, move.end.y], nextSquare);
 691     this.undoOnBoard(move);
 692     return res;
 693   }
 694
 695   displayBonus(move) {
 696     let divBonus = document.createElement("div");
 697     divBonus.classList.add("bonus-text");
 698     divBonus.innerHTML = move.egg;
 699     let container = document.getElementById(this.containerId);
 700     container.appendChild(divBonus);
 701     setTimeout(() => container.removeChild(divBonus), 2000);
 702   }
 703
 704   atLeastOneMove() {
 705     return true;
 706   }
 707
 708   filterValid(moves) {
 709     return moves;
 710   }
 711
 712   // Kingboo bonus can be animated better:
 713   customAnimate(move, segments, cb) {
 714     if (!move.kingboo)
 715       return 0;
 716     super.animateMoving(move.end, move.start, null,
 717                         segments.reverse().map(s => s.reverse()), cb);
 718     return 1;
 719   }
 720
 721 };