public/javascripts/variants/Checkered.js

   1 class CheckeredRules extends ChessRules
   2 {
   3     static getPpath(b)
   4     {
   5         return b[0]=='c' ? "Checkered/"+b : b;
   6     }
   7     static board2fen(b)
   8     {
   9         const checkered_codes = {
  10             'p': 's',
  11             'q': 't',
  12             'r': 'u',
  13             'b': 'c',
  14             'n': 'o',
  15         };
  16         if (b[0]=="c")
  17             return checkered_codes[b[1]];
  18         return ChessRules.board2fen(b);
  19     }
  20     static fen2board(f)
  21     {
  22         const checkered_pieces = {
  23             's': 'p',
  24             't': 'q',
  25             'u': 'r',
  26             'c': 'b',
  27             'o': 'n',
  28         };
  29         if (Object.keys(checkered_pieces).includes(f))
  30             return 'c'+checkered_pieces[f];
  31         return ChessRules.fen2board(f);
  32     }
  33
  34     setFlags(fen)
  35     {
  36         super.setFlags(fen); //castleFlags
  37         this.pawnFlags =
  38         {
  39             "w": new Array(8), //pawns can move 2 squares?
  40             "b": new Array(8)
  41         };
  42         const flags = fen.split(" ")[1].substr(4); //skip first 4 digits, for castle
  43         for (let c of ['w','b'])
  44         {
  45             for (let i=0; i<8; i++)
  46                 this.pawnFlags[c][i] = (flags.charAt((c=='w'?0:8)+i) == '1');
  47         }
  48     }
  49
  50     // Aggregates flags into one object
  51     get flags() {
  52         return [this.castleFlags, this.pawnFlags];
  53     }
  54
  55     // Reverse operation
  56     parseFlags(flags)
  57     {
  58         this.castleFlags = flags[0];
  59         this.pawnFlags = flags[1];
  60     }
  61
  62     canTake([x1,y1], [x2,y2])
  63     {
  64         const color1 = this.getColor(x1,y1);
  65         const color2 = this.getColor(x2,y2);
  66         // Checkered aren't captured
  67         return color1 != color2 && color2 != 'c' && (color1 != 'c' || color2 != this.turn);
  68     }
  69
  70     // Post-processing: apply "checkerization" of standard moves
  71     getPotentialMovesFrom([x,y])
  72     {
  73         let standardMoves = super.getPotentialMovesFrom([x,y]);
  74         const lastRank = this.turn == "w" ? 0 : 7;
  75         if (this.getPiece(x,y) == VariantRules.KING)
  76             return standardMoves; //king has to be treated differently (for castles)
  77         let moves = [];
  78         standardMoves.forEach(m => {
  79             if (m.vanish[0].p == VariantRules.PAWN && Math.abs(m.end.x-m.start.x)==2
  80                 && !this.pawnFlags[this.turn][m.start.y])
  81             {
  82                 return; //skip forbidden 2-squares jumps
  83             }
  84             if (m.vanish.length == 1)
  85                 moves.push(m); //no capture
  86             else
  87             {
  88                 // A capture occured (m.vanish.length == 2)
  89                 m.appear[0].c = "c";
  90                 moves.push(m);
  91                 if (m.appear[0].p != m.vanish[1].p //avoid promotions (already treated):
  92                     && (m.vanish[0].p != VariantRules.PAWN || m.end.x != lastRank))
  93                 {
  94                     // Add transformation into captured piece
  95                     let m2 = JSON.parse(JSON.stringify(m));
  96                     m2.appear[0].p = m.vanish[1].p;
  97                     moves.push(m2);
  98                 }
  99             }
 100         });
 101         return moves;
 102     }
 103
 104     canIplay(side, [x,y])
 105     {
 106         return ((side=='w' && this.moves.length%2==0) || (side=='b' && this.moves.length%2==1))
 107             && [side,'c'].includes(this.getColor(x,y));
 108     }
 109
 110     // Does m2 un-do m1 ? (to disallow undoing checkered moves)
 111     oppositeMoves(m1, m2)
 112     {
 113         return m1.appear.length == 1 && m2.appear.length == 1
 114             && m1.vanish.length == 1 && m2.vanish.length == 1
 115             && m1.start.x == m2.end.x && m1.end.x == m2.start.x
 116             && m1.start.y == m2.end.y && m1.end.y == m2.start.y
 117             && m1.appear[0].c == m2.vanish[0].c && m1.appear[0].p == m2.vanish[0].p
 118             && m1.vanish[0].c == m2.appear[0].c && m1.vanish[0].p == m2.appear[0].p;
 119     }
 120
 121     filterValid(moves)
 122     {
 123         if (moves.length == 0)
 124             return [];
 125         const color = this.turn;
 126         return moves.filter(m => {
 127             const L = this.moves.length;
 128             if (L > 0 && this.oppositeMoves(this.moves[L-1], m))
 129                 return false;
 130             return !this.underCheck(m);
 131         });
 132     }
 133
 134     isAttackedByPawn([x,y], colors)
 135     {
 136         for (let c of colors)
 137         {
 138             const color = (c=="c" ? this.turn : c);
 139             let pawnShift = (color=="w" ? 1 : -1);
 140             if (x+pawnShift>=0 && x+pawnShift<8)
 141             {
 142                 for (let i of [-1,1])
 143                 {
 144                     if (y+i>=0 && y+i<8 && this.getPiece(x+pawnShift,y+i)==VariantRules.PAWN
 145                         && this.getColor(x+pawnShift,y+i)==c)
 146                     {
 147                         return true;
 148                     }
 149                 }
 150             }
 151         }
 152         return false;
 153     }
 154
 155     underCheck(move)
 156     {
 157         const color = this.turn;
 158         this.play(move);
 159         let res = this.isAttacked(this.kingPos[color], [this.getOppCol(color),'c']);
 160         this.undo(move);
 161         return res;
 162     }
 163
 164     getCheckSquares(move)
 165     {
 166         this.play(move);
 167         const color = this.turn;
 168         this.moves.push(move); //artifically change turn, for checkered pawns (TODO)
 169         const kingAttacked = this.isAttacked(this.kingPos[color], [this.getOppCol(color),'c']);
 170         let res = kingAttacked
 171             ? [ JSON.parse(JSON.stringify(this.kingPos[color])) ] //need to duplicate!
 172             : [ ];
 173         this.moves.pop();
 174         this.undo(move);
 175         return res;
 176     }
 177
 178     updateVariables(move)
 179     {
 180         const c = this.getColor(move.start.x,move.start.y);
 181         if (c != 'c') //checkered not concerned by castle flags
 182             super.updateVariables(move);
 183
 184         // Does it turn off a 2-squares pawn flag?
 185         const secondRank = [1,6];
 186         if (secondRank.includes(move.start.x) && move.vanish[0].p == VariantRules.PAWN)
 187             this.pawnFlags[move.start.x==6 ? "w" : "b"][move.start.y] = false;
 188     }
 189
 190     checkGameEnd()
 191     {
 192         const color = this.turn;
 193         this.moves.length++; //artifically change turn, for checkered pawns (TODO)
 194         const res = this.isAttacked(this.kingPos[color], [this.getOppCol(color),'c'])
 195             ? (color == "w" ? "0-1" : "1-0")
 196             : "1/2";
 197         this.moves.length--;
 198         return res;
 199     }
 200
 201     evalPosition()
 202     {
 203         const [sizeX,sizeY] = VariantRules.size;
 204         let evaluation = 0;
 205         //Just count material for now, considering checkered neutral (...)
 206         for (let i=0; i<sizeX; i++)
 207         {
 208             for (let j=0; j<sizeY; j++)
 209             {
 210                 if (this.board[i][j] != VariantRules.EMPTY)
 211                 {
 212                     const sqColor = this.getColor(i,j);
 213                     const sign = sqColor == "w" ? 1 : (sqColor=="b" ? -1 : 0);
 214                     evaluation += sign * VariantRules.VALUES[this.getPiece(i,j)];
 215                 }
 216             }
 217         }
 218         return evaluation;
 219     }
 220
 221     static GenRandInitFen()
 222     {
 223         return ChessRules.GenRandInitFen() + "1111111111111111"; //add 16 pawns flags
 224     }
 225
 226     getFlagsFen()
 227     {
 228         let fen = super.getFlagsFen();
 229         // Add pawns flags
 230         for (let c of ['w','b'])
 231         {
 232             for (let i=0; i<8; i++)
 233                 fen += this.pawnFlags[c][i] ? '1' : '0';
 234         }
 235         return fen;
 236     }
 237
 238     getNotation(move)
 239     {
 240         if (move.appear.length == 2)
 241         {
 242             // Castle
 243             if (move.end.y < move.start.y)
 244                 return "0-0-0";
 245             else
 246                 return "0-0";
 247         }
 248
 249         // Translate final square
 250         let finalSquare =
 251             String.fromCharCode(97 + move.end.y) + (VariantRules.size[0]-move.end.x);
 252
 253         let piece = this.getPiece(move.start.x, move.start.y);
 254         if (piece == VariantRules.PAWN)
 255         {
 256             // Pawn move
 257             let notation = "";
 258             if (move.vanish.length > 1)
 259             {
 260                 // Capture
 261                 let startColumn = String.fromCharCode(97 + move.start.y);
 262                 notation = startColumn + "x" + finalSquare + "=" + move.appear[0].p.toUpperCase();
 263             }
 264             else //no capture
 265                 notation = finalSquare;
 266             if (move.appear.length > 0 && piece != move.appear[0].p) //promotion
 267                 notation += "=" + move.appear[0].p.toUpperCase();
 268             return notation;
 269         }
 270
 271         else
 272         {
 273             // Piece movement
 274             return piece.toUpperCase() + (move.vanish.length > 1 ? "x" : "") + finalSquare
 275                 + (move.vanish.length > 1 ? "=" + move.appear[0].p.toUpperCase() : "");
 276         }
 277     }
 278 }