public/javascripts/variants/Ultima.js

   1 class UltimaRules extends ChessRules
   2 {
   3     static getPpath(b)
   4     {
   5         if (b[1] == "m") //'m' for Immobilizer (I is too similar to 1)
   6             return "Ultima/" + b;
   7         return b; //usual piece
   8     }
   9
  10     initVariables(fen)
  11     {
  12         this.kingPos = {'w':[-1,-1], 'b':[-1,-1]};
  13         const fenParts = fen.split(" ");
  14         const position = fenParts[0].split("/");
  15         for (let i=0; i<position.length; i++)
  16         {
  17             let k = 0;
  18             for (let j=0; j<position[i].length; j++)
  19             {
  20                 switch (position[i].charAt(j))
  21                 {
  22                     case 'k':
  23                         this.kingPos['b'] = [i,k];
  24                         break;
  25                     case 'K':
  26                         this.kingPos['w'] = [i,k];
  27                         break;
  28                     default:
  29                         let num = parseInt(position[i].charAt(j));
  30                         if (!isNaN(num))
  31                             k += (num-1);
  32                 }
  33                 k++;
  34             }
  35         }
  36         this.epSquares = []; //no en-passant here
  37     }
  38
  39     setFlags(fen)
  40     {
  41         // TODO: for compatibility?
  42         this.castleFlags = {"w":[false,false], "b":[false,false]};
  43     }
  44
  45     static get IMMOBILIZER() { return 'm'; }
  46     // Although other pieces keep their names here for coding simplicity,
  47     // keep in mind that:
  48     //  - a "rook" is a coordinator, capturing by coordinating with the king
  49     //  - a "knight" is a long-leaper, capturing as in draughts
  50     //  - a "bishop" is a chameleon, capturing as its prey
  51     //  - a "queen" is a withdrawer, capturing by moving away from pieces
  52
  53     getPotentialMovesFrom([x,y])
  54     {
  55         // Pre-check: is thing on this square immobilized?
  56         // In this case add potential suicide as a move "taking the immobilizer"
  57         const piece = this.getPiece(x,y);
  58         const color = this.getColor(x,y);
  59         const oppCol = this.getOppCol(color);
  60         const V = VariantRules;
  61         const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
  62         const [sizeX,sizeY] = V.size;
  63         for (let step of adjacentSteps)
  64         {
  65             const [i,j] = [x+step[0],y+step[1]];
  66             if (i>=0 && i<sizeX && j>=0 && j<sizeY && this.board[i][j] != V.EMPTY
  67                 && this.getColor(i,j) == oppCol)
  68             {
  69                 const oppPiece = this.getPiece(i,j);
  70                 if (oppPiece == V.IMMOBILIZER
  71                     || (oppPiece == V.BISHOP && piece == V.IMMOBILIZER))
  72                 {
  73                     return [ new Move({
  74                         appear: [],
  75                         vanish: [new PiPo({x:x,y:y,p:piece,c:color})],
  76                         start: {x:x,y:y},
  77                         end: {x:i,y:j}
  78                     }) ];
  79                 }
  80             }
  81         }
  82         switch (this.getPiece(x,y))
  83         {
  84             case VariantRules.IMMOBILIZER:
  85                 return this.getPotentialImmobilizerMoves([x,y]);
  86             default:
  87                 return super.getPotentialMovesFrom([x,y]);
  88         }
  89     }
  90
  91     getSlideNJumpMoves([x,y], steps, oneStep)
  92     {
  93         const color = this.getColor(x,y);
  94         const piece = this.getPiece(x,y);
  95         let moves = [];
  96         const [sizeX,sizeY] = VariantRules.size;
  97         outerLoop:
  98         for (let step of steps)
  99         {
 100             let i = x + step[0];
 101             let j = y + step[1];
 102             while (i>=0 && i<sizeX && j>=0 && j<sizeY
 103                 && this.board[i][j] == VariantRules.EMPTY)
 104             {
 105                 moves.push(this.getBasicMove([x,y], [i,j]));
 106                 if (oneStep !== undefined)
 107                     continue outerLoop;
 108                 i += step[0];
 109                 j += step[1];
 110             }
 111             // Only king can take on occupied square:
 112             if (piece==VariantRules.KING && i>=0 && i<sizeX && j>=0
 113                 && j<sizeY && this.canTake([x,y], [i,j]))
 114             {
 115                 moves.push(this.getBasicMove([x,y], [i,j]));
 116             }
 117         }
 118         return moves;
 119     }
 120
 121     // Modify capturing moves among listed pawn moves
 122     addPawnCaptures(moves, byChameleon)
 123     {
 124         const steps = VariantRules.steps[VariantRules.ROOK];
 125         const [sizeX,sizeY] = VariantRules.size;
 126         const color = this.turn;
 127         const oppCol = this.getOppCol(color);
 128         moves.forEach(m => {
 129             if (!!byChameleon && m.start.x!=m.end.x && m.start.y!=m.end.y)
 130                 return; //chameleon not moving as pawn
 131             // Try capturing in every direction
 132             for (let step of steps)
 133             {
 134                 const sq2 = [m.end.x+2*step[0],m.end.y+2*step[1]];
 135                 if (sq2[0]>=0 && sq2[0]<sizeX && sq2[1]>=0 && sq2[1]<sizeY
 136                     && this.board[sq2[0]][sq2[1]] != VariantRules.EMPTY
 137                     && this.getColor(sq2[0],sq2[1]) == color)
 138                 {
 139                     // Potential capture
 140                     const sq1 = [m.end.x+step[0],m.end.y+step[1]];
 141                     if (this.board[sq1[0]][sq1[1]] != VariantRules.EMPTY
 142                         && this.getColor(sq1[0],sq1[1]) == oppCol)
 143                     {
 144                         const piece1 = this.getPiece(sq1[0],sq1[1]);
 145                         if (!byChameleon || piece1 == VariantRules.PAWN)
 146                         {
 147                             m.vanish.push(new PiPo({
 148                                 x:sq1[0],
 149                                 y:sq1[1],
 150                                 c:oppCol,
 151                                 p:piece1
 152                             }));
 153                         }
 154                     }
 155                 }
 156             }
 157         });
 158     }
 159
 160     // "Pincher"
 161     getPotentialPawnMoves([x,y])
 162     {
 163         let moves = super.getPotentialRookMoves([x,y]);
 164         this.addPawnCaptures(moves);
 165         return moves;
 166     }
 167
 168     addRookCaptures(moves, byChameleon)
 169     {
 170         const color = this.turn;
 171         const oppCol = this.getOppCol(color);
 172         const kp = this.kingPos[color];
 173         moves.forEach(m => {
 174             // Check piece-king rectangle (if any) corners for enemy pieces
 175             if (m.end.x == kp[0] || m.end.y == kp[1])
 176                 return; //"flat rectangle"
 177             const corner1 = [Math.max(m.end.x,kp[0]), Math.min(m.end.y,kp[1])];
 178             const corner2 = [Math.min(m.end.x,kp[0]), Math.max(m.end.y,kp[1])];
 179             for (let [i,j] of [corner1,corner2])
 180             {
 181                 if (this.board[i][j] != VariantRules.EMPTY && this.getColor(i,j) == oppCol)
 182                 {
 183                     const piece = this.getPiece(i,j);
 184                     if (!byChameleon || piece == VariantRules.ROOK)
 185                     {
 186                         m.vanish.push( new PiPo({
 187                             x:i,
 188                             y:j,
 189                             p:piece,
 190                             c:oppCol
 191                         }) );
 192                     }
 193                 }
 194             }
 195         });
 196     }
 197
 198     // Coordinator
 199     getPotentialRookMoves(sq)
 200     {
 201         let moves = super.getPotentialQueenMoves(sq);
 202         this.addRookCaptures(moves);
 203         return moves;
 204     }
 205
 206     // Long-leaper
 207     getKnightCaptures(startSquare, byChameleon)
 208     {
 209         // Look in every direction for captures
 210         const V = VariantRules;
 211         const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
 212         const [sizeX,sizeY] = V.size;
 213         const color = this.turn;
 214         const oppCol = this.getOppCol(color);
 215         let moves = [];
 216         const [x,y] = [startSquare[0],startSquare[1]];
 217         const piece = this.getPiece(x,y); //might be a chameleon!
 218         outerLoop:
 219         for (let step of steps)
 220         {
 221             let [i,j] = [x+step[0], y+step[1]];
 222             while (i>=0 && i<sizeX && j>=0 && j<sizeY && this.board[i][j]==V.EMPTY)
 223             {
 224                 i += step[0];
 225                 j += step[1];
 226             }
 227             if (i<0 || i>=sizeX || j<0 || j>=sizeY || this.getColor(i,j)==color
 228                 || (!!byChameleon && this.getPiece(i,j)!=V.KNIGHT))
 229             {
 230                 continue;
 231             }
 232             // last(thing), cur(thing) : stop if "cur" is our color, or beyond board limits,
 233             // or if "last" isn't empty and cur neither. Otherwise, if cur is empty then
 234             // add move until cur square; if cur is occupied then stop if !!byChameleon and
 235             // the square not occupied by a leaper.
 236             let last = [i,j];
 237             let cur = [i+step[0],j+step[1]];
 238             let vanished = [ new PiPo({x:x,y:y,c:color,p:piece}) ];
 239             while (cur[0]>=0 && cur[0]<sizeX && cur[1]>=0 && cur[1]<sizeY)
 240             {
 241                 if (this.board[last[0]][last[1]] != V.EMPTY)
 242                 {
 243                     const oppPiece = this.getPiece(last[0],last[1]);
 244                     if (!!byChameleon && oppPiece != V.KNIGHT)
 245                         continue outerLoop;
 246                     // Something to eat:
 247                     vanished.push( new PiPo({x:last[0],y:last[1],c:oppCol,p:oppPiece}) );
 248                 }
 249                 if (this.board[cur[0]][cur[1]] != V.EMPTY)
 250                 {
 251                     if (this.getColor(cur[0],cur[1]) == color
 252                         || this.board[last[0]][last[1]] != V.EMPTY) //TODO: redundant test
 253                     {
 254                         continue outerLoop;
 255                     }
 256                 }
 257                 else
 258                 {
 259                     moves.push(new Move({
 260                         appear: [ new PiPo({x:cur[0],y:cur[1],c:color,p:piece}) ],
 261                         vanish: JSON.parse(JSON.stringify(vanished)), //TODO: required?
 262                         start: {x:x,y:y},
 263                         end: {x:cur[0],y:cur[1]}
 264                     }));
 265                 }
 266                 last = [last[0]+step[0],last[1]+step[1]];
 267                 cur = [cur[0]+step[0],cur[1]+step[1]];
 268             }
 269         }
 270         return moves;
 271     }
 272
 273     // Long-leaper
 274     getPotentialKnightMoves(sq)
 275     {
 276         return super.getPotentialQueenMoves(sq).concat(this.getKnightCaptures(sq));
 277     }
 278
 279     getPotentialBishopMoves([x,y])
 280     {
 281         let moves = super.getPotentialQueenMoves([x,y])
 282             .concat(this.getKnightCaptures([x,y],"asChameleon"));
 283         this.addPawnCaptures(moves, "asChameleon");
 284         this.addRookCaptures(moves, "asChameleon");
 285         this.addQueenCaptures(moves, "asChameleon");
 286         // Add king capture if it's within range
 287         const oppKp = this.kingPos[this.getOppCol(this.turn)];
 288         if (Math.abs(x-oppKp[0]) <= 1 && Math.abs(y-oppKp[1]) <= 1)
 289             moves.push(this.getBasicMove([x,y],oppKp));
 290         // Post-processing: merge similar moves, concatenating vanish arrays
 291         let mergedMoves = {};
 292         const [sizeX,sizeY] = VariantRules.size;
 293         moves.forEach(m => {
 294             const key = m.end.x + sizeX * m.end.y;
 295             if (!mergedMoves[key])
 296                 mergedMoves[key] = m;
 297             else
 298             {
 299                 for (let i=1; i<m.vanish.length; i++)
 300                     mergedMoves[key].vanish.push(m.vanish[i]);
 301             }
 302         });
 303         // Finally return an array
 304         moves = [];
 305         Object.keys(mergedMoves).forEach(k => { moves.push(mergedMoves[k]); });
 306         return moves;
 307     }
 308
 309     // Withdrawer
 310     addQueenCaptures(moves, byChameleon)
 311     {
 312         if (moves.length == 0)
 313             return;
 314         const [x,y] = [moves[0].start.x,moves[0].start.y];
 315         const V = VariantRules;
 316         const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
 317         let capturingDirections = [];
 318         const color = this.turn;
 319         const oppCol = this.getOppCol(color);
 320         const [sizeX,sizeY] = V.size;
 321         adjacentSteps.forEach(step => {
 322             const [i,j] = [x+step[0],y+step[1]];
 323             if (i>=0 && i<sizeX && j>=0 && j<sizeY
 324                 && this.board[i][j] != V.EMPTY && this.getColor(i,j) == oppCol
 325                 && (!byChameleon || this.getPiece(i,j) == V.QUEEN))
 326             {
 327                 capturingDirections.push(step);
 328             }
 329         });
 330         moves.forEach(m => {
 331             const step = [
 332                 m.end.x!=x ? (m.end.x-x)/Math.abs(m.end.x-x) : 0,
 333                 m.end.y!=y ? (m.end.y-y)/Math.abs(m.end.y-y) : 0
 334             ];
 335             // NOTE: includes() and even _.isEqual() functions fail...
 336             // TODO: this test should be done only once per direction
 337             if (capturingDirections.some(dir =>
 338                 { return (dir[0]==-step[0] && dir[1]==-step[1]); }))
 339             {
 340                 const [i,j] = [x-step[0],y-step[1]];
 341                 m.vanish.push(new PiPo({
 342                     x:i,
 343                     y:j,
 344                     p:this.getPiece(i,j),
 345                     c:oppCol
 346                 }));
 347             }
 348         });
 349     }
 350
 351     getPotentialQueenMoves(sq)
 352     {
 353         let moves = super.getPotentialQueenMoves(sq);
 354         this.addQueenCaptures(moves);
 355         return moves;
 356     }
 357
 358     getPotentialImmobilizerMoves(sq)
 359     {
 360         // Immobilizer doesn't capture
 361         return super.getPotentialQueenMoves(sq);
 362     }
 363
 364     getPotentialKingMoves(sq)
 365     {
 366         const V = VariantRules;
 367         return this.getSlideNJumpMoves(sq,
 368             V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
 369     }
 370
 371     underCheck(move)
 372     {
 373         return false; //there is no check
 374     }
 375
 376     getCheckSquares(move)
 377     {
 378         const c = this.getOppCol(this.turn); //opponent
 379         const saveKingPos = this.kingPos[c]; //king might be taken
 380         this.play(move);
 381         // The only way to be "under check" is to have lost the king (thus game over)
 382         let res = this.kingPos[c][0] < 0
 383             ? [ JSON.parse(JSON.stringify(saveKingPos)) ]
 384             : [ ];
 385         this.undo(move);
 386         return res;
 387     }
 388
 389     updateVariables(move)
 390     {
 391         // Just update king(s) position(s)
 392         const piece = this.getPiece(move.start.x,move.start.y);
 393         const c = this.getColor(move.start.x,move.start.y);
 394         if (piece == VariantRules.KING && move.appear.length > 0)
 395         {
 396             this.kingPos[c][0] = move.appear[0].x;
 397             this.kingPos[c][1] = move.appear[0].y;
 398         }
 399         // Does this move takes opponent's king?
 400         const oppCol = this.getOppCol(c);
 401         for (let i=1; i<move.vanish.length; i++)
 402         {
 403             if (move.vanish[i].p == VariantRules.KING)
 404             {
 405                 this.kingPos[oppCol] = [-1,-1];
 406                 break;
 407             }
 408         }
 409     }
 410
 411     unupdateVariables(move)
 412     {
 413         super.unupdateVariables(move);
 414         const c = this.getColor(move.start.x,move.start.y);
 415         const oppCol = this.getOppCol(c);
 416         if (this.kingPos[oppCol][0] < 0)
 417         {
 418             // Last move took opponent's king
 419             for (let i=1; i<move.vanish.length; i++)
 420             {
 421                 const psq = move.vanish[i];
 422                 if (psq.p == 'k')
 423                 {
 424                     this.kingPos[oppCol] = [psq.x, psq.y];
 425                     break;
 426                 }
 427             }
 428         }
 429     }
 430
 431     checkGameOver()
 432     {
 433         if (this.checkRepetition())
 434             return "1/2";
 435
 436         const color = this.turn;
 437         if (this.atLeastOneMove() && this.kingPos[color][0] >= 0)
 438             return "*";
 439
 440         return this.checkGameEnd();
 441     }
 442
 443     checkGameEnd()
 444     {
 445         // Stalemate, or our king disappeared
 446         return this.turn == "w" ? "0-1" : "1-0";
 447     }
 448
 449     static get VALUES() { //TODO: totally experimental!
 450         return {
 451             'p': 1,
 452             'r': 2,
 453             'n': 5,
 454             'b': 3,
 455             'q': 3,
 456             'm': 5,
 457             'k': 1000
 458         };
 459     }
 460
 461     static get SEARCH_DEPTH() { return 2; } //TODO?
 462
 463     static get THRESHOLD_MATE() {
 464         return 500; //checkmates evals may be slightly below 1000
 465     }
 466
 467     static GenRandInitFen()
 468     {
 469         let pieces = { "w": new Array(8), "b": new Array(8) };
 470         // Shuffle pieces on first and last rank
 471         for (let c of ["w","b"])
 472         {
 473             let positions = _.range(8);
 474             // Get random squares for every piece, totally freely
 475
 476             let randIndex = _.random(7);
 477             const bishop1Pos = positions[randIndex];
 478             positions.splice(randIndex, 1);
 479
 480             randIndex = _.random(6);
 481             const bishop2Pos = positions[randIndex];
 482             positions.splice(randIndex, 1);
 483
 484             randIndex = _.random(5);
 485             const knight1Pos = positions[randIndex];
 486             positions.splice(randIndex, 1);
 487
 488             randIndex = _.random(4);
 489             const knight2Pos = positions[randIndex];
 490             positions.splice(randIndex, 1);
 491
 492             randIndex = _.random(3);
 493             const queenPos = positions[randIndex];
 494             positions.splice(randIndex, 1);
 495
 496             randIndex = _.random(2);
 497             const kingPos = positions[randIndex];
 498             positions.splice(randIndex, 1);
 499
 500             randIndex = _.random(1);
 501             const rookPos = positions[randIndex];
 502             positions.splice(randIndex, 1);
 503             const immobilizerPos = positions[0];
 504
 505             pieces[c][bishop1Pos] = 'b';
 506             pieces[c][bishop2Pos] = 'b';
 507             pieces[c][knight1Pos] = 'n';
 508             pieces[c][knight2Pos] = 'n';
 509             pieces[c][queenPos] = 'q';
 510             pieces[c][kingPos] = 'k';
 511             pieces[c][rookPos] = 'r';
 512             pieces[c][immobilizerPos] = 'm';
 513         }
 514         return pieces["b"].join("") +
 515             "/pppppppp/8/8/8/8/PPPPPPPP/" +
 516             pieces["w"].join("").toUpperCase() +
 517             " 0000"; //TODO: flags?!
 518     }
 519
 520     getFlagsFen()
 521     {
 522         return "0000"; //TODO: or "-" ?
 523     }
 524
 525     getNotation(move)
 526     {
 527         if (move.appear.length == 0)
 528         {
 529             const startSquare =
 530                 String.fromCharCode(97 + move.start.y) + (VariantRules.size[0]-move.start.x);
 531             return "^" + startSquare; //suicide
 532         }
 533         return super.getNotation(move);
 534     }
 535 }