| 1 | import ChessRules from "/base_rules.js"; |
| 2 | import { ArrayFun } from "/utils/array.js"; |
| 3 | |
| 4 | export default class AliceRules extends ChessRules { |
| 5 | |
| 6 | static get Options() { |
| 7 | return { |
| 8 | select: C.Options.select, |
| 9 | input: C.Options.input, |
| 10 | styles: [ |
| 11 | "balance", |
| 12 | "capture", |
| 13 | "cylinder", |
| 14 | "dark", |
| 15 | "doublemove", |
| 16 | "progressive", |
| 17 | "zen" |
| 18 | ] |
| 19 | }; |
| 20 | } |
| 21 | |
| 22 | // To the other side of the mirror and back... |
| 23 | static get ALICE_PIECES() { |
| 24 | return { |
| 25 | s: "p", |
| 26 | u: "r", |
| 27 | o: "n", |
| 28 | c: "b", |
| 29 | t: "q", |
| 30 | l: "k" |
| 31 | }; |
| 32 | } |
| 33 | static get ALICE_CODES() { |
| 34 | return { |
| 35 | p: "s", |
| 36 | r: "u", |
| 37 | n: "o", |
| 38 | b: "c", |
| 39 | q: "t", |
| 40 | k: "l" |
| 41 | }; |
| 42 | } |
| 43 | |
| 44 | getPieceType(x, y, p) { |
| 45 | if (!p) |
| 46 | p = super.getPiece(x, y); |
| 47 | return V.ALICE_PIECES[p] || p; |
| 48 | } |
| 49 | |
| 50 | pieces(color, x, y) { |
| 51 | let alices = { |
| 52 | 's': {"class": "alice-pawn", "moveas": "p"}, |
| 53 | 'u': {"class": "alice-rook", "moveas": "r"}, |
| 54 | 'o': {"class": "alice-knight", "moveas": "n"}, |
| 55 | 'c': {"class": "alice-bishop", "moveas": "b"}, |
| 56 | 't': {"class": "alice-queen", "moveas": "q"}, |
| 57 | 'l': {"class": "alice-king", "moveas": "k"} |
| 58 | }; |
| 59 | return Object.assign(alices, super.pieces(color, x, y)); |
| 60 | } |
| 61 | |
| 62 | fromSameWorld(p1, p2) { |
| 63 | return ( |
| 64 | (V.ALICE_PIECES[p1] && V.ALICE_PIECES[p2]) || |
| 65 | (V.ALICE_CODES[p1] && V.ALICE_CODES[p2]) |
| 66 | ); |
| 67 | } |
| 68 | |
| 69 | // Step of p over i,j ? |
| 70 | canStepOver(i, j, p) { |
| 71 | return ( |
| 72 | this.board[i][j] == "" || !this.fromSameWorld(this.getPiece(i, j), p)); |
| 73 | } |
| 74 | |
| 75 | // NOTE: castle & enPassant |
| 76 | // https://www.chessvariants.com/other.dir/alice.html |
| 77 | getPotentialMovesFrom([x, y]) { |
| 78 | return super.getPotentialMovesFrom([x, y]).filter(m => { |
| 79 | // Remove moves landing on occupied square on other board |
| 80 | return ( |
| 81 | this.board[m.end.x][m.end.y] == "" || |
| 82 | this.fromSameWorld(m.vanish[0].p, m.vanish[1].p) |
| 83 | ); |
| 84 | }).map(m => { |
| 85 | // Apply Alice rule: go to the other side of the mirror |
| 86 | if (Object.keys(V.ALICE_CODES).includes(m.vanish[0].p)) |
| 87 | // Board 1 |
| 88 | m.appear.forEach(a => a.p = V.ALICE_CODES[a.p]) |
| 89 | else |
| 90 | // Board 2 |
| 91 | m.appear.forEach(a => a.p = V.ALICE_PIECES[a.p]) |
| 92 | return m; |
| 93 | }); |
| 94 | } |
| 95 | |
| 96 | isKing(symbol) { |
| 97 | return ['k', 'l'].includes(symbol); |
| 98 | } |
| 99 | |
| 100 | getCurrentScore() { |
| 101 | const color = this.turn; |
| 102 | const inCheck = this.underCheck(this.searchKingPos(color)); |
| 103 | let someLegalMove = false; |
| 104 | // Search for legal moves: if any is found and |
| 105 | // does not change king world (if under check), then game not over. |
| 106 | for (let i=0; i<this.size.x; i++) { |
| 107 | for (let j=0; j<this.size.y; j++) { |
| 108 | if (this.getColor(i, j) == color) { |
| 109 | const moves = this.filterValid(this.getPotentialMovesFrom([i, j])); |
| 110 | if ( |
| 111 | moves.length >= 1 && |
| 112 | ( |
| 113 | !inCheck || |
| 114 | moves.some(m => m.vanish.every(v => !this.isKing(v.p))) |
| 115 | ) |
| 116 | ) { |
| 117 | return "*"; |
| 118 | } |
| 119 | } |
| 120 | } |
| 121 | } |
| 122 | // Couldn't find any legal move |
| 123 | return (inCheck ? "1/2" : (color == 'w' ? "0-1" : "1-0")); |
| 124 | } |
| 125 | |
| 126 | }; |