| 1 | import { ChessRules, PiPo } from "@/base_rules"; |
| 2 | |
| 3 | export class KoopaRules extends ChessRules { |
| 4 | static get HasEnpassant() { |
| 5 | return false; |
| 6 | } |
| 7 | |
| 8 | static get STUNNED() { |
| 9 | return ['s', 'u', 'o', 'c', 't', 'l']; |
| 10 | } |
| 11 | |
| 12 | static get PIECES() { |
| 13 | return ChessRules.PIECES.concat(V.STUNNED); |
| 14 | } |
| 15 | |
| 16 | static ParseFen(fen) { |
| 17 | let res = ChessRules.ParseFen(fen); |
| 18 | const fenParts = fen.split(" "); |
| 19 | res.stunned = fenParts[4]; |
| 20 | return res; |
| 21 | } |
| 22 | |
| 23 | static IsGoodFen(fen) { |
| 24 | if (!ChessRules.IsGoodFen(fen)) return false; |
| 25 | const fenParsed = V.ParseFen(fen); |
| 26 | // 5) Check "stunned" |
| 27 | if ( |
| 28 | !fenParsed.stunned || |
| 29 | ( |
| 30 | fenParsed.stunned != "-" && |
| 31 | !fenParsed.stunned.match(/^([a-h][1-8][1-4],?)*$/) |
| 32 | ) |
| 33 | ) { |
| 34 | return false; |
| 35 | } |
| 36 | return true; |
| 37 | } |
| 38 | |
| 39 | getPpath(b) { |
| 40 | return (V.STUNNED.includes(b[1]) ? "Koopa/" : "") + b; |
| 41 | } |
| 42 | |
| 43 | getFen() { |
| 44 | return super.getFen() + " " + this.getStunnedFen(); |
| 45 | } |
| 46 | |
| 47 | getFenForRepeat() { |
| 48 | return super.getFenForRepeat() + "_" + this.getStunnedFen(); |
| 49 | } |
| 50 | |
| 51 | getStunnedFen() { |
| 52 | const squares = Object.keys(this.stunned); |
| 53 | if (squares.length == 0) return "-"; |
| 54 | return squares.map(square => square + this.stunned[square]).join(","); |
| 55 | } |
| 56 | |
| 57 | // Base GenRandInitFen() is fine because en-passant indicator will |
| 58 | // stand for stunned indicator. |
| 59 | |
| 60 | scanKings(fen) { |
| 61 | this.INIT_COL_KING = { w: -1, b: -1 }; |
| 62 | // Squares of white and black king: |
| 63 | this.kingPos = { w: [-1, -1], b: [-1, -1] }; |
| 64 | const fenRows = V.ParseFen(fen).position.split("/"); |
| 65 | const startRow = { 'w': V.size.x - 1, 'b': 0 }; |
| 66 | for (let i = 0; i < fenRows.length; i++) { |
| 67 | let k = 0; //column index on board |
| 68 | for (let j = 0; j < fenRows[i].length; j++) { |
| 69 | switch (fenRows[i].charAt(j)) { |
| 70 | case "k": |
| 71 | case "l": |
| 72 | this.kingPos["b"] = [i, k]; |
| 73 | this.INIT_COL_KING["b"] = k; |
| 74 | break; |
| 75 | case "K": |
| 76 | case "L": |
| 77 | this.kingPos["w"] = [i, k]; |
| 78 | this.INIT_COL_KING["w"] = k; |
| 79 | break; |
| 80 | default: { |
| 81 | const num = parseInt(fenRows[i].charAt(j), 10); |
| 82 | if (!isNaN(num)) k += num - 1; |
| 83 | } |
| 84 | } |
| 85 | k++; |
| 86 | } |
| 87 | } |
| 88 | } |
| 89 | |
| 90 | setOtherVariables(fen) { |
| 91 | super.setOtherVariables(fen); |
| 92 | let stunnedArray = []; |
| 93 | const stunnedFen = V.ParseFen(fen).stunned; |
| 94 | if (stunnedFen != "-") { |
| 95 | stunnedArray = |
| 96 | stunnedFen |
| 97 | .split(",") |
| 98 | .map(s => { |
| 99 | return { |
| 100 | square: s.substr(0, 2), |
| 101 | state: parseInt(s[2], 10) |
| 102 | }; |
| 103 | }); |
| 104 | } |
| 105 | this.stunned = {}; |
| 106 | stunnedArray.forEach(s => { |
| 107 | this.stunned[s.square] = s.state; |
| 108 | }); |
| 109 | } |
| 110 | |
| 111 | getNormalizedStep(step) { |
| 112 | const [deltaX, deltaY] = [Math.abs(step[0]), Math.abs(step[1])]; |
| 113 | if (deltaX == 0 || deltaY == 0 || deltaX == deltaY) |
| 114 | return [step[0] / deltaX || 0, step[1] / deltaY || 0]; |
| 115 | // Knight: |
| 116 | const divisor = Math.min(deltaX, deltaY) |
| 117 | return [step[0] / divisor, step[1] / divisor]; |
| 118 | } |
| 119 | |
| 120 | getPotentialMovesFrom([x, y]) { |
| 121 | let moves = super.getPotentialMovesFrom([x, y]).filter(m => { |
| 122 | if ( |
| 123 | m.vanish[0].p != V.PAWN || |
| 124 | m.appear[0].p == V.PAWN || |
| 125 | m.vanish.length == 1 |
| 126 | ) { |
| 127 | return true; |
| 128 | } |
| 129 | // Pawn promotion, "capturing": remove duplicates |
| 130 | return m.appear[0].p == V.QUEEN; |
| 131 | }); |
| 132 | // Complete moves: stuns & kicks |
| 133 | let promoteAfterStun = []; |
| 134 | const color = this.turn; |
| 135 | moves.forEach(m => { |
| 136 | if (m.vanish.length == 2 && m.appear.length == 1) { |
| 137 | const step = |
| 138 | this.getNormalizedStep([m.end.x - m.start.x, m.end.y - m.start.y]); |
| 139 | // "Capture" something: is target stunned? |
| 140 | if (V.STUNNED.includes(m.vanish[1].p)) { |
| 141 | // Kick it: continue movement in the same direction, |
| 142 | // destroying all on its path. |
| 143 | let [i, j] = [m.end.x + step[0], m.end.y + step[1]]; |
| 144 | while (V.OnBoard(i, j)) { |
| 145 | if (this.board[i][j] != V.EMPTY) { |
| 146 | m.vanish.push( |
| 147 | new PiPo({ |
| 148 | x: i, |
| 149 | y: j, |
| 150 | c: this.getColor(i, j), |
| 151 | p: this.getPiece(i, j) |
| 152 | }) |
| 153 | ); |
| 154 | } |
| 155 | i += step[0]; |
| 156 | j += step[1]; |
| 157 | } |
| 158 | } |
| 159 | else { |
| 160 | // The piece is now stunned |
| 161 | m.appear.push(JSON.parse(JSON.stringify(m.vanish[1]))); |
| 162 | const pIdx = ChessRules.PIECES.findIndex(p => p == m.appear[1].p); |
| 163 | m.appear[1].p = V.STUNNED[pIdx]; |
| 164 | // And the capturer continue in the same direction until an empty |
| 165 | // square or the edge of the board, maybe stunning other pieces. |
| 166 | let [i, j] = [m.end.x + step[0], m.end.y + step[1]]; |
| 167 | while (V.OnBoard(i, j) && this.board[i][j] != V.EMPTY) { |
| 168 | const colIJ = this.getColor(i, j); |
| 169 | const pieceIJ = this.getPiece(i, j); |
| 170 | let pIdx = ChessRules.PIECES.findIndex(p => p == pieceIJ); |
| 171 | if (pIdx >= 0) { |
| 172 | // The piece isn't already stunned |
| 173 | m.vanish.push( |
| 174 | new PiPo({ |
| 175 | x: i, |
| 176 | y: j, |
| 177 | c: colIJ, |
| 178 | p: pieceIJ |
| 179 | }) |
| 180 | ); |
| 181 | m.appear.push( |
| 182 | new PiPo({ |
| 183 | x: i, |
| 184 | y: j, |
| 185 | c: colIJ, |
| 186 | p: V.STUNNED[pIdx] |
| 187 | }) |
| 188 | ); |
| 189 | } |
| 190 | i += step[0]; |
| 191 | j += step[1]; |
| 192 | } |
| 193 | if (V.OnBoard(i, j)) { |
| 194 | m.appear[0].x = i; |
| 195 | m.appear[0].y = j; |
| 196 | // Is it a pawn on last rank? |
| 197 | if ( |
| 198 | m.appear[0].p == V.PAWN && |
| 199 | ((color == 'w' && i == 0) || (color == 'b' && i == 7)) |
| 200 | ) { |
| 201 | m.appear[0].p = V.ROOK; |
| 202 | for (let ppiece of [V.KNIGHT, V.BISHOP, V.QUEEN]) { |
| 203 | let mp = JSON.parse(JSON.stringify(m)); |
| 204 | mp.appear[0].p = ppiece; |
| 205 | promoteAfterStun.push(mp); |
| 206 | } |
| 207 | } |
| 208 | } |
| 209 | else |
| 210 | // The piece is out |
| 211 | m.appear.shift(); |
| 212 | } |
| 213 | } |
| 214 | }); |
| 215 | return moves.concat(promoteAfterStun); |
| 216 | } |
| 217 | |
| 218 | getPotentialKingMoves(sq) { |
| 219 | return ( |
| 220 | this.getSlideNJumpMoves( |
| 221 | sq, |
| 222 | V.steps[V.ROOK].concat(V.steps[V.BISHOP]), |
| 223 | "oneStep" |
| 224 | ).concat(super.getCastleMoves(sq, true, ['r'])) |
| 225 | ); |
| 226 | } |
| 227 | |
| 228 | filterValid(moves) { |
| 229 | // Forbid kicking own king out |
| 230 | const color = this.turn; |
| 231 | return moves.filter(m => { |
| 232 | const kingVanish = |
| 233 | m.vanish.some(v => v.c == color && ['k', 'l'].includes(v.p)); |
| 234 | if (kingVanish) { |
| 235 | const kingAppear = |
| 236 | m.appear.some(a => a.c == color && ['k', 'l'].includes(a.p)); |
| 237 | return kingAppear; |
| 238 | } |
| 239 | return true; |
| 240 | }); |
| 241 | } |
| 242 | |
| 243 | getCheckSquares() { |
| 244 | return []; |
| 245 | } |
| 246 | |
| 247 | getCurrentScore() { |
| 248 | if (this.kingPos['w'][0] < 0) return "0-1"; |
| 249 | if (this.kingPos['b'][0] < 0) return "1-0"; |
| 250 | if (!this.atLeastOneMove()) return "1/2"; |
| 251 | return "*"; |
| 252 | } |
| 253 | |
| 254 | postPlay(move) { |
| 255 | // Base method is fine because a stunned king (which won't be detected) |
| 256 | // can still castle after going back to normal. |
| 257 | super.postPlay(move); |
| 258 | const color = this.turn; |
| 259 | const kp = this.kingPos[color]; |
| 260 | if ( |
| 261 | this.board[kp[0], kp[1]] == V.EMPTY || |
| 262 | !['k', 'l'].includes(this.getPiece(kp[0], kp[1])) || |
| 263 | this.getColor(kp[0], kp[1]) != color |
| 264 | ) { |
| 265 | // King didn't move by itself, and vanished => game over |
| 266 | this.kingPos[color] = [-1, -1]; |
| 267 | } |
| 268 | move.stunned = JSON.stringify(this.stunned); |
| 269 | // Array of stunned stage 1 pieces (just back to normal then) |
| 270 | Object.keys(this.stunned).forEach(square => { |
| 271 | // All (formerly) stunned pieces progress by 1 level, if still on board |
| 272 | const coords = V.SquareToCoords(square); |
| 273 | const [x, y] = [coords.x, coords.y]; |
| 274 | if (V.STUNNED.includes(this.board[x][y][1])) { |
| 275 | // Stunned piece still on board |
| 276 | this.stunned[square]--; |
| 277 | if (this.stunned[square] == 0) { |
| 278 | delete this.stunned[square]; |
| 279 | const color = this.getColor(x, y); |
| 280 | const piece = this.getPiece(x, y); |
| 281 | const pIdx = V.STUNNED.findIndex(p => p == piece); |
| 282 | this.board[x][y] = color + ChessRules.PIECES[pIdx]; |
| 283 | } |
| 284 | } |
| 285 | else delete this.stunned[square]; |
| 286 | }); |
| 287 | // Any new stunned pieces? |
| 288 | move.appear.forEach(a => { |
| 289 | if (V.STUNNED.includes(a.p)) |
| 290 | // Set to maximum stun level: |
| 291 | this.stunned[V.CoordsToSquare({ x: a.x, y: a.y })] = 4; |
| 292 | }); |
| 293 | } |
| 294 | |
| 295 | postUndo(move) { |
| 296 | super.postUndo(move); |
| 297 | const oppCol = V.GetOppCol(this.turn); |
| 298 | if (this.kingPos[oppCol][0] < 0) { |
| 299 | // Opponent's king vanished |
| 300 | const psq = |
| 301 | move.vanish.find((v,i) => i >= 1 && ['k', 'l'].includes(v.p)); |
| 302 | this.kingPos[oppCol] = [psq.x, psq.y]; |
| 303 | } |
| 304 | this.stunned = JSON.parse(move.stunned); |
| 305 | for (let i=0; i<8; i++) { |
| 306 | for (let j=0; j<8; j++) { |
| 307 | const square = V.CoordsToSquare({ x: i, y: j }); |
| 308 | const pieceIJ = this.getPiece(i, j); |
| 309 | if (!this.stunned[square]) { |
| 310 | const pIdx = V.STUNNED.findIndex(p => p == pieceIJ); |
| 311 | if (pIdx >= 0) |
| 312 | this.board[i][j] = this.getColor(i, j) + ChessRules.PIECES[pIdx]; |
| 313 | } |
| 314 | else { |
| 315 | const pIdx = ChessRules.PIECES.findIndex(p => p == pieceIJ); |
| 316 | if (pIdx >= 0) |
| 317 | this.board[i][j] = this.getColor(i, j) + V.STUNNED[pIdx]; |
| 318 | } |
| 319 | } |
| 320 | } |
| 321 | } |
| 322 | |
| 323 | static get VALUES() { |
| 324 | return Object.assign( |
| 325 | { |
| 326 | s: 1, |
| 327 | u: 5, |
| 328 | o: 3, |
| 329 | c: 3, |
| 330 | t: 9, |
| 331 | l: 1000 |
| 332 | }, |
| 333 | ChessRules.VALUES |
| 334 | ); |
| 335 | } |
| 336 | |
| 337 | static get SEARCH_DEPTH() { |
| 338 | return 2; |
| 339 | } |
| 340 | |
| 341 | getNotation(move) { |
| 342 | if ( |
| 343 | move.appear.length == 2 && |
| 344 | move.vanish.length == 2 && |
| 345 | move.appear.concat(move.vanish).every( |
| 346 | av => ChessRules.PIECES.includes(av.p)) && |
| 347 | move.appear[0].p == V.KING |
| 348 | ) { |
| 349 | if (move.end.y < move.start.y) return "0-0-0"; |
| 350 | return "0-0"; |
| 351 | } |
| 352 | const finalSquare = V.CoordsToSquare(move.end); |
| 353 | const piece = this.getPiece(move.start.x, move.start.y); |
| 354 | const captureMark = move.vanish.length >= 2 ? "x" : ""; |
| 355 | let pawnMark = ""; |
| 356 | if (piece == 'p' && captureMark.length == 1) |
| 357 | pawnMark = V.CoordToColumn(move.start.y); //start column |
| 358 | // Piece or pawn movement |
| 359 | let notation = |
| 360 | (piece == V.PAWN ? pawnMark : piece.toUpperCase()) + |
| 361 | captureMark + finalSquare; |
| 362 | if ( |
| 363 | piece == 'p' && |
| 364 | move.appear[0].c == move.vanish[0].c && |
| 365 | move.appear[0].p != 'p' |
| 366 | ) { |
| 367 | // Promotion |
| 368 | notation += "=" + move.appear[0].p.toUpperCase(); |
| 369 | } |
| 370 | return notation; |
| 371 | } |
| 372 | }; |