Commit | Line | Data |
---|---|---|
107dc1bd BA |
1 | import { ChessRules, Move, PiPo } from "@/base_rules"; |
2 | import { randInt } from "@/utils/alea"; | |
3 | ||
4 | export class TeleportRules extends ChessRules { | |
90df90bc BA |
5 | hoverHighlight(x, y) { |
6 | // TODO: only highlight if the move is legal | |
7 | return (this.subTurn == 2 && this.board[x][y] == V.EMPTY); | |
8 | } | |
9 | ||
107dc1bd BA |
10 | setOtherVariables(fen) { |
11 | super.setOtherVariables(fen); | |
12 | this.subTurn = 1; | |
13 | this.firstMove = []; | |
14 | } | |
15 | ||
16 | canTake([x1, y1], [x2, y2]) { | |
17 | return this.subTurn == 1; | |
18 | } | |
19 | ||
20 | getPPpath(m) { | |
21 | if ( | |
22 | m.vanish.length == 2 && | |
23 | m.appear.length == 1 && | |
24 | m.vanish[0].c == m.vanish[1].c && | |
25 | m.appear[0].p == V.KING | |
26 | ) { | |
27 | // Rook teleportation with the king | |
28 | return this.getPpath(m.vanish[1].c + m.vanish[1].p); | |
29 | } | |
30 | return this.getPpath(m.appear[0].c + m.appear[0].p); | |
31 | } | |
32 | ||
33 | getPotentialMovesFrom([x, y]) { | |
34 | if (this.subTurn == 1) return super.getPotentialMovesFrom([x, y]); | |
35 | // subTurn == 2: a move is a click, not handled here | |
36 | return []; | |
37 | } | |
38 | ||
39 | filterValid(moves) { | |
40 | if (this.subTurn == 2) return super.filterValid(moves); | |
41 | const color = this.turn; | |
42 | return moves.filter(m => { | |
43 | this.play(m); | |
44 | let res = false; | |
45 | if ( | |
46 | m.vanish.length == 1 || | |
47 | m.appear.length == 2 || | |
48 | m.vanish[0].c != m.vanish[1].c | |
49 | ) { | |
50 | // Standard check: | |
51 | res = !this.underCheck(color); | |
52 | } | |
53 | else { | |
54 | // Self-capture: find landing square not resulting in check | |
55 | outerLoop: for (let i=0; i<8; i++) { | |
56 | for (let j=0; j<8; j++) { | |
57 | if ( | |
58 | this.board[i][j] == V.EMPTY && | |
59 | ( | |
60 | m.vanish[1].p != V.PAWN || | |
61 | i != (color == 'w' ? 0 : 7) | |
62 | ) | |
63 | ) { | |
64 | const tMove = new Move({ | |
65 | appear: [ | |
66 | new PiPo({ | |
67 | x: i, | |
68 | y: j, | |
69 | c: color, | |
70 | // The dropped piece nature has no importance: | |
71 | p: V.KNIGHT | |
72 | }) | |
73 | ], | |
74 | vanish: [], | |
75 | start: { x: -1, y: -1 } | |
76 | }); | |
77 | this.play(tMove); | |
78 | const moveOk = !this.underCheck(color); | |
79 | this.undo(tMove); | |
80 | if (moveOk) { | |
81 | res = true; | |
82 | break outerLoop; | |
83 | } | |
84 | } | |
85 | } | |
86 | } | |
87 | } | |
88 | this.undo(m); | |
89 | return res; | |
90 | }); | |
91 | } | |
92 | ||
93 | getAllValidMoves() { | |
94 | if (this.subTurn == 1) return super.getAllValidMoves(); | |
95 | // Subturn == 2: only teleportations | |
96 | let moves = []; | |
97 | const L = this.firstMove.length; | |
98 | const color = this.turn; | |
99 | for (let i=0; i<8; i++) { | |
100 | for (let j=0; j<8; j++) { | |
101 | if ( | |
102 | this.board[i][j] == V.EMPTY && | |
103 | ( | |
104 | this.firstMove[L-1].vanish[1].p != V.PAWN || | |
105 | i != (color == 'w' ? 0 : 7) | |
106 | ) | |
107 | ) { | |
108 | const tMove = new Move({ | |
109 | appear: [ | |
110 | new PiPo({ | |
111 | x: i, | |
112 | y: j, | |
113 | c: color, | |
114 | p: this.firstMove[L-1].vanish[1].p | |
115 | }) | |
116 | ], | |
117 | vanish: [], | |
118 | start: { x: -1, y: -1 } | |
119 | }); | |
120 | this.play(tMove); | |
121 | const moveOk = !this.underCheck(color); | |
122 | this.undo(tMove); | |
123 | if (moveOk) moves.push(tMove); | |
124 | } | |
125 | } | |
126 | } | |
127 | return moves; | |
128 | } | |
129 | ||
130 | underCheck(color) { | |
131 | if (this.kingPos[color][0] < 0) | |
132 | // King is being moved: | |
133 | return false; | |
134 | return super.underCheck(color); | |
135 | } | |
136 | ||
137 | getCurrentScore() { | |
138 | if (this.subTurn == 2) | |
139 | // Move not over | |
140 | return "*"; | |
141 | return super.getCurrentScore(); | |
142 | } | |
143 | ||
144 | doClick(square) { | |
145 | if (isNaN(square[0])) return null; | |
146 | // If subTurn == 2 && square is empty && !underCheck, then teleport | |
147 | if (this.subTurn == 2 && this.board[square[0]][square[1]] == V.EMPTY) { | |
148 | const L = this.firstMove.length; | |
149 | const color = this.turn; | |
150 | if ( | |
151 | this.firstMove[L-1].vanish[1].p == V.PAWN && | |
152 | square[0] == (color == 'w' ? 0 : 7) | |
153 | ) { | |
154 | // Pawns cannot be teleported on last rank | |
155 | return null; | |
156 | } | |
157 | const tMove = new Move({ | |
158 | appear: [ | |
159 | new PiPo({ | |
160 | x: square[0], | |
161 | y: square[1], | |
162 | c: color, | |
163 | p: this.firstMove[L-1].vanish[1].p | |
164 | }) | |
165 | ], | |
166 | vanish: [], | |
167 | start: { x: -1, y: -1 } | |
168 | }); | |
169 | this.play(tMove); | |
170 | const moveOk = !this.underCheck(color); | |
171 | this.undo(tMove); | |
172 | if (moveOk) return tMove; | |
173 | } | |
174 | return null; | |
175 | } | |
176 | ||
177 | play(move) { | |
178 | move.flags = JSON.stringify(this.aggregateFlags()); | |
179 | if (move.vanish.length > 0) { | |
180 | this.epSquares.push(this.getEpSquare(move)); | |
181 | this.firstMove.push(move); | |
182 | } | |
183 | V.PlayOnBoard(this.board, move); | |
184 | if ( | |
185 | this.subTurn == 2 || | |
186 | move.vanish.length == 1 || | |
187 | move.appear.length == 2 || | |
188 | move.vanish[0].c != move.vanish[1].c | |
189 | ) { | |
190 | this.turn = V.GetOppCol(this.turn); | |
191 | this.subTurn = 1; | |
192 | this.movesCount++; | |
193 | } | |
194 | else this.subTurn = 2; | |
195 | this.postPlay(move); | |
196 | } | |
197 | ||
198 | postPlay(move) { | |
199 | if (move.vanish.length == 2 && move.vanish[1].p == V.KING) | |
200 | // A king is moved: temporarily off board | |
201 | this.kingPos[move.vanish[1].c] = [-1, -1]; | |
202 | else if (move.appear[0].p == V.KING) | |
203 | this.kingPos[move.appear[0].c] = [move.appear[0].x, move.appear[0].y]; | |
204 | this.updateCastleFlags(move); | |
205 | } | |
206 | ||
207 | // NOTE: no need to update if castleFlags already off | |
208 | updateCastleFlags(move) { | |
209 | if (move.vanish.length == 0) return; | |
210 | const c = move.vanish[0].c; | |
211 | if ( | |
212 | move.vanish.length == 2 && | |
213 | move.appear.length == 1 && | |
214 | move.vanish[0].c == move.vanish[1].c | |
215 | ) { | |
216 | // Self-capture: of the king or a rook? | |
217 | if (move.vanish[1].p == V.KING) | |
218 | this.castleFlags[c] = [V.size.y, V.size.y]; | |
219 | else if (move.vanish[1].p == V.ROOK) { | |
220 | const firstRank = (c == "w" ? V.size.x - 1 : 0); | |
221 | if ( | |
222 | move.end.x == firstRank && | |
223 | this.castleFlags[c].includes(move.end.y) | |
224 | ) { | |
225 | const flagIdx = (move.end.y == this.castleFlags[c][0] ? 0 : 1); | |
226 | this.castleFlags[c][flagIdx] = V.size.y; | |
227 | } | |
228 | } | |
229 | } | |
230 | else { | |
231 | // Normal move | |
232 | const firstRank = (c == "w" ? V.size.x - 1 : 0); | |
233 | const oppCol = V.GetOppCol(c); | |
234 | const oppFirstRank = V.size.x - 1 - firstRank; | |
235 | if (move.vanish[0].p == V.KING && move.appear.length > 0) | |
236 | this.castleFlags[c] = [V.size.y, V.size.y]; | |
237 | else if ( | |
238 | move.start.x == firstRank && | |
239 | this.castleFlags[c].includes(move.start.y) | |
240 | ) { | |
241 | const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1); | |
242 | this.castleFlags[c][flagIdx] = V.size.y; | |
243 | } | |
244 | if ( | |
245 | move.end.x == oppFirstRank && | |
246 | this.castleFlags[oppCol].includes(move.end.y) | |
247 | ) { | |
248 | const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1); | |
249 | this.castleFlags[oppCol][flagIdx] = V.size.y; | |
250 | } | |
251 | } | |
252 | } | |
253 | ||
254 | undo(move) { | |
255 | this.disaggregateFlags(JSON.parse(move.flags)); | |
256 | if (move.vanish.length > 0) { | |
257 | this.epSquares.pop(); | |
258 | this.firstMove.pop(); | |
259 | } | |
260 | V.UndoOnBoard(this.board, move); | |
261 | if (this.subTurn == 2) this.subTurn = 1; | |
262 | else { | |
263 | this.turn = V.GetOppCol(this.turn); | |
264 | this.movesCount--; | |
265 | this.subTurn = (move.vanish.length > 0 ? 1 : 2); | |
266 | } | |
267 | this.postUndo(move); | |
268 | } | |
269 | ||
270 | postUndo(move) { | |
271 | if (move.vanish.length == 0) { | |
272 | if (move.appear[0].p == V.KING) | |
273 | // A king was teleported | |
274 | this.kingPos[move.appear[0].c] = [-1, -1]; | |
275 | } | |
276 | else if (move.vanish.length == 2 && move.vanish[1].p == V.KING) | |
277 | // A king was (self-)taken | |
278 | this.kingPos[move.vanish[1].c] = [move.end.x, move.end.y]; | |
279 | else super.postUndo(move); | |
280 | } | |
281 | ||
282 | getComputerMove() { | |
283 | let moves = this.getAllValidMoves(); | |
284 | if (moves.length == 0) return null; | |
285 | // Custom "search" at depth 1 (for now. TODO?) | |
286 | const maxeval = V.INFINITY; | |
287 | const color = this.turn; | |
288 | const initEval = this.evalPosition(); | |
289 | moves.forEach(m => { | |
290 | this.play(m); | |
291 | m.eval = (color == "w" ? -1 : 1) * maxeval; | |
292 | if ( | |
293 | m.vanish.length == 2 && | |
294 | m.appear.length == 1 && | |
295 | m.vanish[0].c == m.vanish[1].c | |
296 | ) { | |
297 | const moves2 = this.getAllValidMoves(); | |
298 | m.next = moves2[0]; | |
299 | moves2.forEach(m2 => { | |
300 | this.play(m2); | |
301 | const score = this.getCurrentScore(); | |
ff0150d1 BA |
302 | let mvEval = 0; |
303 | if (["1-0", "0-1"].includes(score)) | |
304 | mvEval = (score == "1-0" ? 1 : -1) * maxeval; | |
305 | else if (score == "*") | |
306 | // Add small fluctuations to avoid dropping pieces always on the | |
307 | // first square available. | |
308 | mvEval = initEval + 0.05 - Math.random() / 10; | |
107dc1bd BA |
309 | if ( |
310 | (color == 'w' && mvEval > m.eval) || | |
311 | (color == 'b' && mvEval < m.eval) | |
312 | ) { | |
313 | // TODO: if many second moves have the same eval, only the | |
314 | // first is kept. Could be randomized. | |
315 | m.eval = mvEval; | |
316 | m.next = m2; | |
317 | } | |
318 | this.undo(m2); | |
319 | }); | |
320 | } | |
321 | else { | |
322 | const score = this.getCurrentScore(); | |
323 | if (score != "1/2") { | |
324 | if (score != "*") m.eval = (score == "1-0" ? 1 : -1) * maxeval; | |
325 | else m.eval = this.evalPosition(); | |
326 | } | |
327 | } | |
328 | this.undo(m); | |
329 | }); | |
330 | moves.sort((a, b) => { | |
331 | return (color == "w" ? 1 : -1) * (b.eval - a.eval); | |
332 | }); | |
333 | let candidates = [0]; | |
334 | for (let i = 1; i < moves.length && moves[i].eval == moves[0].eval; i++) | |
335 | candidates.push(i); | |
336 | const mIdx = candidates[randInt(candidates.length)]; | |
337 | if (!moves[mIdx].next) return moves[mIdx]; | |
338 | const move2 = moves[mIdx].next; | |
339 | delete moves[mIdx]["next"]; | |
340 | return [moves[mIdx], move2]; | |
341 | } | |
342 | ||
343 | getNotation(move) { | |
344 | if (move.vanish.length > 0) return super.getNotation(move); | |
345 | // Teleportation: | |
346 | const piece = | |
347 | move.appear[0].p != V.PAWN ? move.appear[0].p.toUpperCase() : ""; | |
348 | return piece + "@" + V.CoordsToSquare(move.end); | |
349 | } | |
350 | }; |