| 1 | import { ChessRules } from "@/base_rules"; |
| 2 | import { randInt } from "@/utils/alea"; |
| 3 | |
| 4 | export class RefusalRules extends ChessRules { |
| 5 | |
| 6 | static IsGoodFen(fen) { |
| 7 | if (!ChessRules.IsGoodFen(fen)) return false; |
| 8 | if (!V.ParseFen(fen).lastMove) return false; |
| 9 | return true; |
| 10 | } |
| 11 | |
| 12 | static ParseFen(fen) { |
| 13 | return Object.assign( |
| 14 | { lastMove: fen.split(" ")[5] }, |
| 15 | ChessRules.ParseFen(fen) |
| 16 | ); |
| 17 | } |
| 18 | |
| 19 | getFen() { |
| 20 | const L = this.lastMove.length; |
| 21 | const lm = this.lastMove[L-1]; |
| 22 | return super.getFen() + " " + JSON.stringify(lm); |
| 23 | } |
| 24 | |
| 25 | // NOTE: with this variant's special rule, |
| 26 | // some extra repetitions could be detected... TODO (...) |
| 27 | |
| 28 | static GenRandInitFen(randomness) { |
| 29 | return ChessRules.GenRandInitFen(randomness) + " null"; |
| 30 | } |
| 31 | |
| 32 | setOtherVariables(fen) { |
| 33 | super.setOtherVariables(fen); |
| 34 | this.lastMove = [JSON.parse(V.ParseFen(fen).lastMove)]; //may be null |
| 35 | } |
| 36 | |
| 37 | canIplay(side, [x, y]) { |
| 38 | if (super.canIplay(side, [x, y])) return true; |
| 39 | if (this.turn != side) return false; |
| 40 | // Check if playing last move, reversed: |
| 41 | const L = this.lastMove.length; |
| 42 | const lm = this.lastMove[L-1]; |
| 43 | return (!!lm && !lm.noRef && x == lm.end.x && y == lm.end.y); |
| 44 | } |
| 45 | |
| 46 | getPotentialMovesFrom([x, y]) { |
| 47 | if (this.getColor(x, y) != this.turn) { |
| 48 | const L = this.lastMove.length; |
| 49 | const lm = this.lastMove[L-1]; |
| 50 | const beforeLastRank = (this.turn == 'w' ? 1 : 6); |
| 51 | if ( |
| 52 | !!lm && !lm.noRef && x == lm.end.x && y == lm.end.y && |
| 53 | (this.getPiece(x, y) != V.PAWN || x != beforeLastRank) |
| 54 | ) { |
| 55 | let revLm = JSON.parse(JSON.stringify(lm)); |
| 56 | let tmp = revLm.appear; |
| 57 | revLm.appear = revLm.vanish; |
| 58 | revLm.vanish = tmp; |
| 59 | tmp = revLm.start; |
| 60 | revLm.start = revLm.end; |
| 61 | revLm.end = tmp; |
| 62 | return [revLm]; |
| 63 | } |
| 64 | return []; |
| 65 | } |
| 66 | return super.getPotentialMovesFrom([x, y]); |
| 67 | } |
| 68 | |
| 69 | // NOTE: do not take refusal move into account here (two own moves) |
| 70 | atLeastTwoMoves() { |
| 71 | let movesCounter = 0; |
| 72 | const color = this.turn; |
| 73 | for (let i = 0; i < V.size.x; i++) { |
| 74 | for (let j = 0; j < V.size.y; j++) { |
| 75 | if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) { |
| 76 | const moves = this.getPotentialMovesFrom([i, j]); |
| 77 | for (let m of moves) { |
| 78 | if (m.vanish[0].c == color && this.filterValid([m]).length > 0) { |
| 79 | movesCounter++; |
| 80 | if (movesCounter >= 2) return true; |
| 81 | } |
| 82 | } |
| 83 | } |
| 84 | } |
| 85 | } |
| 86 | return false; |
| 87 | } |
| 88 | |
| 89 | filterValid(moves) { |
| 90 | if (moves.length == 0) return []; |
| 91 | const color = this.turn; |
| 92 | const L = this.lastMove.length; |
| 93 | const lm = this.lastMove[L-1]; |
| 94 | return moves.filter(m => { |
| 95 | if ( |
| 96 | !!lm && !!lm.refusal && |
| 97 | m.start.x == lm.end.x && m.start.y == lm.end.y && |
| 98 | m.end.x == lm.start.x && m.end.y == lm.start.y && |
| 99 | (m.vanish[0].p != V.PAWN || m.appear[0].p == lm.vanish[0].p) |
| 100 | ) { |
| 101 | return false; |
| 102 | } |
| 103 | // NOTE: not using this.play()/undo() ==> infinite loop |
| 104 | V.PlayOnBoard(this.board, m); |
| 105 | if (m.appear[0].p == V.KING) |
| 106 | this.kingPos[m.appear[0].c] = [m.appear[0].x, m.appear[0].y]; |
| 107 | const res = !this.underCheck(color); |
| 108 | V.UndoOnBoard(this.board, m); |
| 109 | if (m.vanish[0].p == V.KING) |
| 110 | this.kingPos[m.vanish[0].c] = [m.vanish[0].x, m.vanish[0].y]; |
| 111 | return res; |
| 112 | }); |
| 113 | } |
| 114 | |
| 115 | prePlay(move) { |
| 116 | const L = this.lastMove.length; |
| 117 | const lm = this.lastMove[L-1]; |
| 118 | if ( |
| 119 | // My previous move was already refused? |
| 120 | (!!lm && this.getColor(lm.end.x, lm.end.y) == this.turn) || |
| 121 | // I've only one move available? |
| 122 | !this.atLeastTwoMoves() |
| 123 | ) { |
| 124 | move.noRef = true; |
| 125 | } |
| 126 | // NOTE: refusal could be recomputed, but, it's easier like this |
| 127 | if (move.vanish[0].c != this.turn) move.refusal = true; |
| 128 | } |
| 129 | |
| 130 | getEpSquare(move) { |
| 131 | if (!move.refusal) return super.getEpSquare(move); |
| 132 | return null; //move refusal |
| 133 | } |
| 134 | |
| 135 | postPlay(move) { |
| 136 | if (!move.refusal) super.postPlay(move); |
| 137 | else { |
| 138 | const L = this.lastMove.length; |
| 139 | const lm = this.lastMove[L-1]; |
| 140 | this.disaggregateFlags(JSON.parse(lm.flags)); |
| 141 | } |
| 142 | // NOTE: explicitely give fields, because some are assigned in BaseGame |
| 143 | let mvInLm = { |
| 144 | start: move.start, |
| 145 | end: move.end, |
| 146 | appear: move.appear, |
| 147 | vanish: move.vanish, |
| 148 | flags: move.flags |
| 149 | }; |
| 150 | if (!!move.noRef) mvInLm.noRef = true; |
| 151 | if (!!move.refusal) mvInLm.refusal = true; |
| 152 | this.lastMove.push(mvInLm); |
| 153 | } |
| 154 | |
| 155 | postUndo(move) { |
| 156 | if (!move.refusal) super.postUndo(move); |
| 157 | this.lastMove.pop(); |
| 158 | } |
| 159 | |
| 160 | getAllPotentialMoves() { |
| 161 | const color = this.turn; |
| 162 | const L = this.lastMove.length; |
| 163 | const lm = this.lastMove[L-1]; |
| 164 | let potentialMoves = []; |
| 165 | for (let i = 0; i < V.size.x; i++) { |
| 166 | for (let j = 0; j < V.size.y; j++) { |
| 167 | if ( |
| 168 | this.board[i][j] != V.EMPTY && |
| 169 | ( |
| 170 | this.getColor(i, j) == color || |
| 171 | // Add move refusal: |
| 172 | (!!lm && lm.end.x == i && lm.end.y == j) |
| 173 | ) |
| 174 | ) { |
| 175 | Array.prototype.push.apply( |
| 176 | potentialMoves, |
| 177 | this.getPotentialMovesFrom([i, j]) |
| 178 | ); |
| 179 | } |
| 180 | } |
| 181 | } |
| 182 | return potentialMoves; |
| 183 | } |
| 184 | |
| 185 | getComputerMove() { |
| 186 | // Just play at random for now... (TODO?) |
| 187 | // Refuse last move with odds 1/3. |
| 188 | const moves = this.getAllValidMoves(); |
| 189 | const refusal = moves.find(m => m.vanish[0].c != this.turn); |
| 190 | if (!!refusal) { |
| 191 | if (Math.random() <= 0.33) return refusal; |
| 192 | const others = moves.filter(m => m.vanish[0].c == this.turn); |
| 193 | return others[randInt(others.length)]; |
| 194 | } |
| 195 | else return moves[randInt(moves.length)]; |
| 196 | } |
| 197 | |
| 198 | getNotation(move) { |
| 199 | if (move.vanish[0].c != this.turn) return "Refuse"; |
| 200 | return super.getNotation(move); |
| 201 | } |
| 202 | |
| 203 | }; |