Commit | Line | Data |
---|---|---|
5b18515f | 1 | import { ChessRules } from "@/base_rules"; |
0e5fe2f0 | 2 | import { randInt, shuffle } from "@/utils/alea"; |
031b3d07 | 3 | import { ArrayFun } from "@/utils/array"; |
5b18515f BA |
4 | |
5 | export class AmbiguousRules extends ChessRules { | |
6 | static get HasFlags() { | |
7 | return false; | |
8 | } | |
9 | ||
10 | setOtherVariables(fen) { | |
11 | super.setOtherVariables(fen); | |
12 | if (this.movesCount == 0) this.subTurn = 2; | |
13 | else this.subTurn = 1; | |
14 | } | |
15 | ||
16 | // Subturn 1: play a move for the opponent on the designated square. | |
17 | // Subturn 2: play a move for me (which just indicate a square). | |
18 | getPotentialMovesFrom([x, y]) { | |
19 | const color = this.turn; | |
20 | const oppCol = V.GetOppCol(color); | |
21 | if (this.subTurn == 2) { | |
22 | // Just play a normal move (which in fact only indicate a square) | |
ff3a8d16 | 23 | let movesHash = {}; |
5b18515f BA |
24 | return ( |
25 | super.getPotentialMovesFrom([x, y]) | |
ff3a8d16 BA |
26 | .filter(m => { |
27 | // Filter promotions: keep only one, since no choice now. | |
28 | if (m.appear[0].p != m.vanish[0].p) { | |
29 | const hash = V.CoordsToSquare(m.start) + V.CoordsToSquare(m.end); | |
30 | if (!movesHash[hash]) { | |
31 | movesHash[hash] = true; | |
32 | return true; | |
33 | } | |
34 | return false; | |
35 | } | |
36 | return true; | |
37 | }) | |
5b18515f BA |
38 | .map(m => { |
39 | if (m.vanish.length == 1) m.appear[0].p = V.GOAL; | |
40 | else m.appear[0].p = V.TARGET_CODE[m.vanish[1].p]; | |
41 | m.appear[0].c = oppCol; | |
42 | m.vanish.shift(); | |
43 | return m; | |
44 | }) | |
45 | ); | |
46 | } | |
47 | // At subTurn == 1, play a targeted move for opponent | |
48 | // Search for target (we could also have it in a stack...) | |
49 | let target = { x: -1, y: -1 }; | |
50 | outerLoop: for (let i = 0; i < V.size.x; i++) { | |
51 | for (let j = 0; j < V.size.y; j++) { | |
52 | if (this.board[i][j] != V.EMPTY) { | |
53 | const piece = this.board[i][j][1]; | |
54 | if ( | |
55 | piece == V.GOAL || | |
56 | Object.keys(V.TARGET_DECODE).includes(piece) | |
57 | ) { | |
58 | target = { x: i, y: j}; | |
59 | break outerLoop; | |
60 | } | |
61 | } | |
62 | } | |
63 | } | |
64 | // TODO: could be more efficient than generating all moves. | |
65 | this.turn = oppCol; | |
66 | const emptyTarget = (this.board[target.x][target.y][1] == V.GOAL); | |
67 | if (emptyTarget) this.board[target.x][target.y] = V.EMPTY; | |
68 | let moves = super.getPotentialMovesFrom([x, y]); | |
69 | if (emptyTarget) { | |
70 | this.board[target.x][target.y] = color + V.GOAL; | |
71 | moves.forEach(m => { | |
72 | m.vanish.push({ | |
73 | x: target.x, | |
74 | y: target.y, | |
75 | c: color, | |
76 | p: V.GOAL | |
77 | }); | |
78 | }); | |
79 | } | |
80 | this.turn = color; | |
81 | return moves.filter(m => m.end.x == target.x && m.end.y == target.y); | |
82 | } | |
83 | ||
84 | canIplay(side, [x, y]) { | |
85 | const color = this.getColor(x, y); | |
86 | return ( | |
87 | (this.subTurn == 1 && color != side) || | |
88 | (this.subTurn == 2 && color == side) | |
89 | ); | |
90 | } | |
91 | ||
92 | getPpath(b) { | |
93 | if (b[1] == V.GOAL || Object.keys(V.TARGET_DECODE).includes(b[1])) | |
94 | return "Ambiguous/" + b; | |
95 | return b; | |
96 | } | |
97 | ||
98 | // Code for empty square target | |
99 | static get GOAL() { | |
100 | return 'g'; | |
101 | } | |
102 | ||
103 | static get TARGET_DECODE() { | |
104 | return { | |
105 | 's': 'p', | |
106 | 't': 'q', | |
107 | 'u': 'r', | |
108 | 'o': 'n', | |
109 | 'c': 'b', | |
110 | 'l': 'k' | |
111 | }; | |
112 | } | |
113 | ||
114 | static get TARGET_CODE() { | |
115 | return { | |
116 | 'p': 's', | |
117 | 'q': 't', | |
118 | 'r': 'u', | |
119 | 'n': 'o', | |
120 | 'b': 'c', | |
121 | 'k': 'l' | |
122 | }; | |
123 | } | |
124 | ||
125 | static get PIECES() { | |
126 | return ( | |
127 | ChessRules.PIECES.concat(Object.keys(V.TARGET_DECODE)).concat([V.GOAL]) | |
128 | ); | |
129 | } | |
130 | ||
131 | getAllPotentialMoves() { | |
132 | const color = this.turn; | |
133 | let potentialMoves = []; | |
134 | for (let i = 0; i < V.size.x; i++) { | |
135 | for (let j = 0; j < V.size.y; j++) { | |
a15bd0da | 136 | const colIJ = this.getColor(i, j); |
5b18515f BA |
137 | if ( |
138 | this.board[i][j] != V.EMPTY && | |
a15bd0da BA |
139 | ( |
140 | (this.subTurn == 2 && colIJ == color) || | |
141 | ( | |
142 | this.subTurn == 1 && colIJ != color && | |
143 | this.board[i][j][1] != V.GOAL && | |
144 | !(Object.keys(V.TARGET_DECODE).includes(this.board[i][j][1])) | |
145 | ) | |
146 | ) | |
5b18515f BA |
147 | ) { |
148 | Array.prototype.push.apply( | |
149 | potentialMoves, | |
150 | this.getPotentialMovesFrom([i, j]) | |
151 | ); | |
152 | } | |
153 | } | |
154 | } | |
155 | return potentialMoves; | |
156 | } | |
157 | ||
158 | atLeastOneMove() { | |
159 | // Since there are no checks this seems true (same as for Magnetic...) | |
160 | return true; | |
161 | } | |
162 | ||
163 | filterValid(moves) { | |
164 | return moves; | |
165 | } | |
166 | ||
167 | getCheckSquares() { | |
168 | return []; | |
169 | } | |
170 | ||
171 | getCurrentScore() { | |
172 | // This function is only called at subTurn 1 | |
173 | const color = V.GetOppCol(this.turn); | |
174 | if (this.kingPos[color][0] < 0) return (color == 'w' ? "0-1" : "1-0"); | |
175 | return "*"; | |
176 | } | |
177 | ||
178 | prePlay(move) { | |
179 | const c = V.GetOppCol(this.turn); | |
180 | const piece = move.vanish[0].p; | |
181 | if (piece == V.KING) { | |
182 | // (Opp) king moves: | |
183 | this.kingPos[c][0] = move.appear[0].x; | |
184 | this.kingPos[c][1] = move.appear[0].y; | |
185 | } | |
186 | if (move.vanish.length == 2 && [V.KING, 'l'].includes(move.vanish[1].p)) | |
187 | // (My) king is captured: | |
188 | this.kingPos[this.turn] = [-1, -1]; | |
189 | } | |
190 | ||
191 | play(move) { | |
192 | let kingCaptured = false; | |
193 | if (this.subTurn == 1) { | |
194 | this.prePlay(move); | |
195 | this.epSquares.push(this.getEpSquare(move)); | |
196 | kingCaptured = this.kingPos[this.turn][0] < 0; | |
197 | } | |
198 | if (kingCaptured) move.kingCaptured = true; | |
199 | V.PlayOnBoard(this.board, move); | |
200 | if (this.subTurn == 2 || kingCaptured) { | |
201 | this.turn = V.GetOppCol(this.turn); | |
202 | this.movesCount++; | |
203 | } | |
204 | if (!kingCaptured) this.subTurn = 3 - this.subTurn; | |
205 | } | |
206 | ||
207 | undo(move) { | |
208 | if (!move.kingCaptured) this.subTurn = 3 - this.subTurn; | |
209 | if (this.subTurn == 2 || !!move.kingCaptured) { | |
210 | this.turn = V.GetOppCol(this.turn); | |
211 | this.movesCount--; | |
212 | } | |
213 | V.UndoOnBoard(this.board, move); | |
214 | if (this.subTurn == 1) { | |
215 | this.epSquares.pop(); | |
216 | this.postUndo(move); | |
217 | } | |
218 | } | |
219 | ||
220 | postUndo(move) { | |
221 | // (Potentially) Reset king(s) position | |
222 | const c = V.GetOppCol(this.turn); | |
223 | const piece = move.vanish[0].p; | |
224 | if (piece == V.KING) { | |
225 | // (Opp) king moved: | |
226 | this.kingPos[c][0] = move.vanish[0].x; | |
227 | this.kingPos[c][1] = move.vanish[0].y; | |
228 | } | |
229 | if (move.vanish.length == 2 && [V.KING, 'l'].includes(move.vanish[1].p)) | |
230 | // (My) king was captured: | |
231 | this.kingPos[this.turn] = [move.vanish[1].x, move.vanish[1].y]; | |
232 | } | |
233 | ||
234 | static GenRandInitFen(randomness) { | |
235 | if (randomness == 0) | |
236 | return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 -"; | |
237 | ||
238 | let pieces = { w: new Array(8), b: new Array(8) }; | |
239 | for (let c of ["w", "b"]) { | |
240 | if (c == 'b' && randomness == 1) { | |
241 | pieces['b'] = pieces['w']; | |
242 | break; | |
243 | } | |
244 | ||
245 | // Get random squares for every piece, totally freely | |
246 | let positions = shuffle(ArrayFun.range(8)); | |
247 | const composition = ['b', 'b', 'r', 'r', 'n', 'n', 'k', 'q']; | |
248 | const rem2 = positions[0] % 2; | |
249 | if (rem2 == positions[1] % 2) { | |
250 | // Fix bishops (on different colors) | |
251 | for (let i=2; i<8; i++) { | |
252 | if (positions[i] % 2 != rem2) | |
253 | [positions[1], positions[i]] = [positions[i], positions[1]]; | |
254 | } | |
255 | } | |
256 | for (let i = 0; i < 8; i++) pieces[c][positions[i]] = composition[i]; | |
257 | } | |
258 | return ( | |
259 | pieces["b"].join("") + | |
260 | "/pppppppp/8/8/8/8/PPPPPPPP/" + | |
261 | pieces["w"].join("").toUpperCase() + | |
262 | // En-passant allowed, but no flags | |
263 | " w 0 -" | |
264 | ); | |
265 | } | |
266 | ||
a15bd0da BA |
267 | getComputerMove() { |
268 | let moves = this.getAllValidMoves(); | |
269 | if (moves.length == 0) return null; | |
270 | // Random mover for now | |
271 | const color = this.turn; | |
272 | const m1 = moves[randInt(moves.length)]; | |
273 | this.play(m1); | |
274 | let m = undefined; | |
275 | if (this.turn != color) m = m1; | |
276 | else { | |
277 | const moves2 = this.getAllValidMoves(); | |
278 | m = [m1, moves2[randInt(moves2.length)]]; | |
279 | } | |
280 | this.undo(m1); | |
281 | return m; | |
282 | } | |
283 | ||
5b18515f BA |
284 | getNotation(move) { |
285 | if (this.subTurn == 2) return "T:" + V.CoordsToSquare(move.end); | |
286 | // Remove and re-add target to get a good notation: | |
287 | const withTarget = move.vanish[1]; | |
288 | if (move.vanish[1].p == V.GOAL) move.vanish.pop(); | |
289 | else move.vanish[1].p = V.TARGET_DECODE[move.vanish[1].p]; | |
290 | const notation = super.getNotation(move); | |
291 | if (move.vanish.length == 1) move.vanish.push(withTarget); | |
292 | else move.vanish[1].p = V.TARGET_CODE[move.vanish[1].p]; | |
293 | return notation; | |
294 | } | |
295 | }; |