Commit | Line | Data |
---|---|---|
6e47d367 BA |
1 | import { ChessRules, PiPo, Move } from "@/base_rules"; |
2 | import { ArrayFun } from "@/utils/array"; | |
3 | import { randInt, shuffle } from "@/utils/alea"; | |
4 | ||
5 | export class InterweaveRules extends ChessRules { | |
6 | static get HasFlags() { | |
7 | return false; | |
8 | } | |
9 | ||
10 | static GenRandInitFen(randomness) { | |
11 | if (randomness == 0) | |
12 | return "rbnkknbr/pppppppp/8/8/8/8/PPPPPPPP/RBNKKNBR w 0 - 000000"; | |
13 | ||
14 | let pieces = { w: new Array(8), b: new Array(8) }; | |
15 | for (let c of ["w", "b"]) { | |
16 | if (c == 'b' && randomness == 1) { | |
17 | pieces['b'] = pieces['w']; | |
18 | break; | |
19 | } | |
20 | ||
21 | // Each pair of pieces on 2 colors: | |
22 | const composition = ['r', 'n', 'b', 'k', 'r', 'n', 'b', 'k']; | |
23 | let positions = shuffle(ArrayFun.range(4)); | |
24 | for (let i = 0; i < 4; i++) | |
25 | pieces[c][2 * positions[i]] = composition[i]; | |
26 | positions = shuffle(ArrayFun.range(4)); | |
27 | for (let i = 0; i < 4; i++) | |
28 | pieces[c][2 * positions[i] + 1] = composition[i]; | |
29 | } | |
30 | return ( | |
31 | pieces["b"].join("") + | |
32 | "/pppppppp/8/8/8/8/PPPPPPPP/" + | |
33 | pieces["w"].join("").toUpperCase() + | |
34 | // En-passant allowed, but no flags | |
35 | " w 0 - 000000" | |
36 | ); | |
37 | } | |
38 | ||
39 | static IsGoodFen(fen) { | |
40 | if (!ChessRules.IsGoodFen(fen)) return false; | |
41 | const fenParsed = V.ParseFen(fen); | |
42 | // 4) Check captures | |
43 | if (!fenParsed.captured || !fenParsed.captured.match(/^[0-9]{6,6}$/)) | |
44 | return false; | |
45 | return true; | |
46 | } | |
47 | ||
48 | static IsGoodPosition(position) { | |
49 | if (position.length == 0) return false; | |
50 | const rows = position.split("/"); | |
51 | if (rows.length != V.size.x) return false; | |
52 | let kings = { "k": 0, "K": 0 }; | |
53 | for (let row of rows) { | |
54 | let sumElts = 0; | |
55 | for (let i = 0; i < row.length; i++) { | |
56 | if (['K','k'].includes(row[i])) kings[row[i]]++; | |
57 | if (V.PIECES.includes(row[i].toLowerCase())) sumElts++; | |
58 | else { | |
59 | const num = parseInt(row[i]); | |
60 | if (isNaN(num)) return false; | |
61 | sumElts += num; | |
62 | } | |
63 | } | |
64 | if (sumElts != V.size.y) return false; | |
65 | } | |
66 | // Both kings should be on board. Exactly two per color. | |
67 | if (Object.values(kings).some(v => v != 2)) return false; | |
68 | return true; | |
69 | } | |
70 | ||
71 | static ParseFen(fen) { | |
72 | const fenParts = fen.split(" "); | |
73 | return Object.assign( | |
74 | ChessRules.ParseFen(fen), | |
75 | { captured: fenParts[4] } | |
76 | ); | |
77 | } | |
78 | ||
79 | getFen() { | |
80 | return super.getFen() + " " + this.getCapturedFen(); | |
81 | } | |
82 | ||
83 | getFenForRepeat() { | |
84 | return super.getFenForRepeat() + "_" + this.getCapturedFen(); | |
85 | } | |
86 | ||
87 | getCapturedFen() { | |
88 | let counts = [...Array(6).fill(0)]; | |
89 | [V.ROOK, V.KNIGHT, V.BISHOP].forEach((p,idx) => { | |
90 | counts[idx] = this.captured["w"][p]; | |
91 | counts[3 + idx] = this.captured["b"][p]; | |
92 | }); | |
93 | return counts.join(""); | |
94 | } | |
95 | ||
96 | scanKings() {} | |
97 | ||
98 | setOtherVariables(fen) { | |
99 | super.setOtherVariables(fen); | |
100 | const fenParsed = V.ParseFen(fen); | |
101 | // Initialize captured pieces' counts from FEN | |
102 | this.captured = { | |
103 | w: { | |
104 | [V.ROOK]: parseInt(fenParsed.captured[0]), | |
105 | [V.KNIGHT]: parseInt(fenParsed.captured[1]), | |
106 | [V.BISHOP]: parseInt(fenParsed.captured[2]), | |
107 | }, | |
108 | b: { | |
109 | [V.ROOK]: parseInt(fenParsed.captured[3]), | |
110 | [V.KNIGHT]: parseInt(fenParsed.captured[4]), | |
111 | [V.BISHOP]: parseInt(fenParsed.captured[5]), | |
112 | } | |
113 | }; | |
114 | // Stack of "last move" only for intermediate captures | |
115 | this.lastMoveEnd = [null]; | |
116 | } | |
117 | ||
118 | // Trim all non-capturing moves | |
119 | static KeepCaptures(moves) { | |
120 | return moves.filter(m => m.vanish.length >= 2 || m.appear.length == 0); | |
121 | } | |
122 | ||
123 | // Stop at the first capture found (if any) | |
124 | atLeastOneCapture() { | |
125 | const color = this.turn; | |
126 | for (let i = 0; i < V.size.x; i++) { | |
127 | for (let j = 0; j < V.size.y; j++) { | |
128 | if ( | |
129 | this.board[i][j] != V.EMPTY && | |
130 | this.getColor(i, j) == color && | |
131 | V.KeepCaptures(this.getPotentialMovesFrom([i, j])).length > 0 | |
132 | ) { | |
133 | return true; | |
134 | } | |
135 | } | |
136 | } | |
137 | return false; | |
138 | } | |
139 | ||
140 | // En-passant after 2-sq jump | |
141 | getEpSquare(moveOrSquare) { | |
142 | if (!moveOrSquare) return undefined; | |
143 | if (typeof moveOrSquare === "string") { | |
144 | const square = moveOrSquare; | |
145 | if (square == "-") return undefined; | |
146 | // Enemy pawn initial column must be given too: | |
147 | let res = []; | |
148 | const epParts = square.split(","); | |
149 | res.push(V.SquareToCoords(epParts[0])); | |
150 | res.push(V.ColumnToCoord(epParts[1])); | |
151 | return res; | |
152 | } | |
153 | // Argument is a move: | |
154 | const move = moveOrSquare; | |
155 | const [sx, ex, sy, ey] = | |
156 | [move.start.x, move.end.x, move.start.y, move.end.y]; | |
157 | if ( | |
158 | move.vanish.length == 1 && | |
159 | this.getPiece(sx, sy) == V.PAWN && | |
160 | Math.abs(sx - ex) == 2 && | |
161 | Math.abs(sy - ey) == 2 | |
162 | ) { | |
163 | return [ | |
164 | { | |
165 | x: (ex + sx) / 2, | |
166 | y: (ey + sy) / 2 | |
167 | }, | |
168 | // The arrival column must be remembered, because | |
169 | // potentially two pawns could be candidates to be captured: | |
170 | // one on our left, and one on our right. | |
171 | move.end.y | |
172 | ]; | |
173 | } | |
174 | return undefined; //default | |
175 | } | |
176 | ||
177 | static IsGoodEnpassant(enpassant) { | |
178 | if (enpassant != "-") { | |
179 | const epParts = enpassant.split(","); | |
180 | const epSq = V.SquareToCoords(epParts[0]); | |
181 | if (isNaN(epSq.x) || isNaN(epSq.y) || !V.OnBoard(epSq)) return false; | |
182 | const arrCol = V.ColumnToCoord(epParts[1]); | |
183 | if (isNaN(arrCol) || arrCol < 0 || arrCol >= V.size.y) return false; | |
184 | } | |
185 | return true; | |
186 | } | |
187 | ||
188 | getEnpassantFen() { | |
189 | const L = this.epSquares.length; | |
190 | if (!this.epSquares[L - 1]) return "-"; //no en-passant | |
191 | return ( | |
192 | V.CoordsToSquare(this.epSquares[L - 1][0]) + | |
193 | "," + | |
194 | V.CoordToColumn(this.epSquares[L - 1][1]) | |
195 | ); | |
196 | } | |
197 | ||
7ddfec38 | 198 | getPotentialMovesFrom([x, y]) { |
6e47d367 BA |
199 | switch (this.getPiece(x, y)) { |
200 | case V.PAWN: | |
7ddfec38 | 201 | return this.getPotentialPawnMoves([x, y]); |
6e47d367 | 202 | case V.ROOK: |
7ddfec38 | 203 | return this.getPotentialRookMoves([x, y]); |
6e47d367 | 204 | case V.KNIGHT: |
7ddfec38 | 205 | return this.getPotentialKnightMoves([x, y]); |
6e47d367 | 206 | case V.BISHOP: |
7ddfec38 | 207 | return this.getPotentialBishopMoves([x, y]); |
6e47d367 | 208 | case V.KING: |
7ddfec38 | 209 | return this.getPotentialKingMoves([x, y]); |
6e47d367 BA |
210 | // No queens |
211 | } | |
7ddfec38 | 212 | return []; |
6e47d367 BA |
213 | } |
214 | ||
215 | // Special pawns movements | |
216 | getPotentialPawnMoves([x, y]) { | |
217 | const color = this.turn; | |
218 | const oppCol = V.GetOppCol(color); | |
219 | let moves = []; | |
220 | const [sizeX, sizeY] = [V.size.x, V.size.y]; | |
221 | const shiftX = color == "w" ? -1 : 1; | |
222 | const startRank = color == "w" ? sizeX - 2 : 1; | |
223 | const potentialFinalPieces = | |
224 | [V.ROOK, V.KNIGHT, V.BISHOP].filter(p => this.captured[color][p] > 0); | |
225 | const lastRanks = (color == "w" ? [0, 1] : [sizeX - 1, sizeX - 2]); | |
226 | if (x + shiftX == lastRanks[0] && potentialFinalPieces.length == 0) | |
227 | // If no captured piece is available, the pawn cannot promote | |
228 | return []; | |
229 | ||
230 | const finalPieces1 = | |
231 | x + shiftX == lastRanks[0] | |
232 | ? potentialFinalPieces | |
233 | : | |
234 | x + shiftX == lastRanks[1] | |
235 | ? potentialFinalPieces.concat([V.PAWN]) | |
236 | : [V.PAWN]; | |
237 | // One square diagonally | |
238 | for (let shiftY of [-1, 1]) { | |
239 | if (this.board[x + shiftX][y + shiftY] == V.EMPTY) { | |
240 | for (let piece of finalPieces1) { | |
241 | moves.push( | |
242 | this.getBasicMove([x, y], [x + shiftX, y + shiftY], { | |
243 | c: color, | |
244 | p: piece | |
245 | }) | |
246 | ); | |
247 | } | |
248 | if ( | |
249 | V.PawnSpecs.twoSquares && | |
250 | x == startRank && | |
251 | y + 2 * shiftY >= 0 && | |
252 | y + 2 * shiftY < sizeY && | |
253 | this.board[x + 2 * shiftX][y + 2 * shiftY] == V.EMPTY | |
254 | ) { | |
255 | // Two squares jump | |
256 | moves.push( | |
257 | this.getBasicMove([x, y], [x + 2 * shiftX, y + 2 * shiftY]) | |
258 | ); | |
259 | } | |
260 | } | |
261 | } | |
262 | // Capture | |
263 | const finalPieces2 = | |
264 | x + 2 * shiftX == lastRanks[0] | |
265 | ? potentialFinalPieces | |
266 | : | |
267 | x + 2 * shiftX == lastRanks[1] | |
268 | ? potentialFinalPieces.concat([V.PAWN]) | |
269 | : [V.PAWN]; | |
270 | if ( | |
271 | this.board[x + shiftX][y] != V.EMPTY && | |
272 | this.canTake([x, y], [x + shiftX, y]) && | |
273 | V.OnBoard(x + 2 * shiftX, y) && | |
274 | this.board[x + 2 * shiftX][y] == V.EMPTY | |
275 | ) { | |
276 | const oppPiece = this.getPiece(x + shiftX, y); | |
277 | for (let piece of finalPieces2) { | |
278 | let mv = this.getBasicMove( | |
279 | [x, y], [x + 2 * shiftX, y], { c: color, p: piece }); | |
280 | mv.vanish.push({ | |
281 | x: x + shiftX, | |
282 | y: y, | |
283 | p: oppPiece, | |
284 | c: oppCol | |
285 | }); | |
286 | moves.push(mv); | |
287 | } | |
288 | } | |
289 | ||
290 | // En passant | |
291 | const Lep = this.epSquares.length; | |
292 | const epSquare = this.epSquares[Lep - 1]; //always at least one element | |
293 | if ( | |
294 | !!epSquare && | |
295 | epSquare[0].x == x + shiftX && | |
296 | epSquare[0].y == y && | |
297 | this.board[x + 2 * shiftX][y] == V.EMPTY | |
298 | ) { | |
299 | for (let piece of finalPieces2) { | |
300 | let enpassantMove = | |
301 | this.getBasicMove( | |
302 | [x, y], [x + 2 * shiftX, y], { c: color, p: piece}); | |
303 | enpassantMove.vanish.push({ | |
304 | x: x, | |
305 | y: epSquare[1], | |
306 | p: "p", | |
307 | c: this.getColor(x, epSquare[1]) | |
308 | }); | |
309 | moves.push(enpassantMove); | |
310 | } | |
311 | } | |
312 | ||
313 | // Add custodian captures: | |
314 | const steps = V.steps[V.ROOK]; | |
315 | moves.forEach(m => { | |
316 | // Try capturing in every direction | |
317 | for (let step of steps) { | |
318 | const sq2 = [m.end.x + 2 * step[0], m.end.y + 2 * step[1]]; | |
319 | if ( | |
320 | V.OnBoard(sq2[0], sq2[1]) && | |
321 | this.board[sq2[0]][sq2[1]] != V.EMPTY && | |
322 | this.getColor(sq2[0], sq2[1]) == color | |
323 | ) { | |
324 | // Potential capture | |
325 | const sq1 = [m.end.x + step[0], m.end.y + step[1]]; | |
326 | if ( | |
327 | this.board[sq1[0]][sq1[1]] != V.EMPTY && | |
328 | this.getColor(sq1[0], sq1[1]) == oppCol | |
329 | ) { | |
330 | m.vanish.push( | |
331 | new PiPo({ | |
332 | x: sq1[0], | |
333 | y: sq1[1], | |
334 | c: oppCol, | |
335 | p: this.getPiece(sq1[0], sq1[1]) | |
336 | }) | |
337 | ); | |
338 | } | |
339 | } | |
340 | } | |
341 | }); | |
342 | ||
343 | return moves; | |
344 | } | |
345 | ||
346 | getSlides([x, y], steps, options) { | |
347 | options = options || {}; | |
348 | // No captures: | |
349 | let moves = []; | |
350 | outerLoop: for (let step of steps) { | |
351 | let i = x + step[0]; | |
352 | let j = y + step[1]; | |
353 | let counter = 1; | |
354 | while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { | |
355 | if (!options["doubleStep"] || counter % 2 == 0) | |
356 | moves.push(this.getBasicMove([x, y], [i, j])); | |
357 | if (!!options["oneStep"]) continue outerLoop; | |
358 | i += step[0]; | |
359 | j += step[1]; | |
360 | counter++; | |
361 | } | |
362 | } | |
363 | return moves; | |
364 | } | |
365 | ||
366 | // Smasher | |
367 | getPotentialRookMoves([x, y]) { | |
368 | let moves = | |
369 | this.getSlides([x, y], V.steps[V.ROOK], { doubleStep: true }) | |
370 | .concat(this.getSlides([x, y], V.steps[V.BISHOP])); | |
371 | // Add captures | |
372 | const oppCol = V.GetOppCol(this.turn); | |
373 | moves.forEach(m => { | |
374 | const delta = [m.end.x - m.start.x, m.end.y - m.start.y]; | |
375 | const step = [ | |
376 | delta[0] / Math.abs(delta[0]) || 0, | |
377 | delta[1] / Math.abs(delta[1]) || 0 | |
378 | ]; | |
379 | if (step[0] == 0 || step[1] == 0) { | |
380 | // Rook-like move, candidate for capturing | |
381 | const [i, j] = [m.end.x + step[0], m.end.y + step[1]]; | |
382 | if ( | |
383 | V.OnBoard(i, j) && | |
384 | this.board[i][j] != V.EMPTY && | |
385 | this.getColor(i, j) == oppCol | |
386 | ) { | |
387 | m.vanish.push({ | |
388 | x: i, | |
389 | y: j, | |
390 | p: this.getPiece(i, j), | |
391 | c: oppCol | |
392 | }); | |
393 | } | |
394 | } | |
395 | }); | |
396 | return moves; | |
397 | } | |
398 | ||
399 | // Leaper | |
400 | getPotentialKnightMoves([x, y]) { | |
401 | let moves = | |
402 | this.getSlides([x, y], V.steps[V.ROOK], { doubleStep: true }) | |
403 | .concat(this.getSlides([x, y], V.steps[V.BISHOP])); | |
404 | const oppCol = V.GetOppCol(this.turn); | |
405 | // Look for double-knight moves (could capture): | |
406 | for (let step of V.steps[V.KNIGHT]) { | |
407 | const [i, j] = [x + 2 * step[0], y + 2 * step[1]]; | |
408 | if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { | |
409 | const [ii, jj] = [x + step[0], y + step[1]]; | |
410 | if (this.board[ii][jj] == V.EMPTY || this.getColor(ii, jj) == oppCol) { | |
411 | let mv = this.getBasicMove([x, y], [i, j]); | |
412 | if (this.board[ii][jj] != V.EMPTY) { | |
413 | mv.vanish.push({ | |
414 | x: ii, | |
415 | y: jj, | |
416 | c: oppCol, | |
417 | p: this.getPiece(ii, jj) | |
418 | }); | |
419 | } | |
420 | moves.push(mv); | |
421 | } | |
422 | } | |
423 | } | |
424 | // Look for an enemy in every orthogonal direction | |
425 | for (let step of V.steps[V.ROOK]) { | |
426 | let [i, j] = [x + step[0], y+ step[1]]; | |
427 | let counter = 1; | |
428 | while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { | |
429 | i += step[0]; | |
430 | j += step[1]; | |
431 | counter++; | |
432 | } | |
433 | if ( | |
434 | V.OnBoard(i, j) && | |
435 | counter % 2 == 1 && | |
436 | this.getColor(i, j) == oppCol | |
437 | ) { | |
438 | const oppPiece = this.getPiece(i, j); | |
439 | // Candidate for capture: can I land after? | |
440 | let [ii, jj] = [i + step[0], j + step[1]]; | |
441 | counter++; | |
442 | while (V.OnBoard(ii, jj) && this.board[ii][jj] == V.EMPTY) { | |
443 | if (counter % 2 == 0) { | |
444 | // Same color: add capture | |
445 | let mv = this.getBasicMove([x, y], [ii, jj]); | |
446 | mv.vanish.push({ | |
447 | x: i, | |
448 | y: j, | |
449 | c: oppCol, | |
450 | p: oppPiece | |
451 | }); | |
452 | moves.push(mv); | |
453 | } | |
454 | ii += step[0]; | |
455 | jj += step[1]; | |
456 | counter++; | |
457 | } | |
458 | } | |
459 | } | |
460 | return moves; | |
461 | } | |
462 | ||
463 | // Remover | |
464 | getPotentialBishopMoves([x, y]) { | |
465 | let moves = this.getSlides([x, y], V.steps[V.BISHOP]); | |
466 | // Add captures | |
467 | const oppCol = V.GetOppCol(this.turn); | |
468 | let captures = []; | |
469 | for (let step of V.steps[V.ROOK]) { | |
470 | const [i, j] = [x + step[0], y + step[1]]; | |
471 | if ( | |
472 | V.OnBoard(i, j) && | |
473 | this.board[i][j] != V.EMPTY && | |
474 | this.getColor(i, j) == oppCol | |
475 | ) { | |
476 | captures.push([i, j]); | |
477 | } | |
478 | } | |
479 | captures.forEach(c => { | |
480 | moves.push({ | |
481 | start: { x: x, y: y }, | |
482 | end: { x: c[0], y: c[1] }, | |
483 | appear: [], | |
484 | vanish: captures.map(ct => { | |
485 | return { | |
486 | x: ct[0], | |
487 | y: ct[1], | |
488 | c: oppCol, | |
489 | p: this.getPiece(ct[0], ct[1]) | |
490 | }; | |
491 | }) | |
492 | }); | |
493 | }); | |
494 | return moves; | |
495 | } | |
496 | ||
497 | getPotentialKingMoves([x, y]) { | |
498 | let moves = this.getSlides([x, y], V.steps[V.BISHOP], { oneStep: true }); | |
499 | // Add captures | |
500 | const oppCol = V.GetOppCol(this.turn); | |
501 | for (let step of V.steps[V.ROOK]) { | |
502 | const [i, j] = [x + 2 * step[0], y + 2 * step[1]]; | |
503 | if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { | |
504 | const [ii, jj] = [x + step[0], y + step[1]]; | |
505 | if (this.board[ii][jj] != V.EMPTY && this.getColor(ii, jj) == oppCol) { | |
506 | let mv = this.getBasicMove([x, y], [i, j]); | |
507 | mv.vanish.push({ | |
508 | x: ii, | |
509 | y: jj, | |
510 | c: oppCol, | |
511 | p: this.getPiece(ii, jj) | |
512 | }); | |
513 | moves.push(mv); | |
514 | } | |
515 | } | |
516 | } | |
517 | return moves; | |
518 | } | |
519 | ||
520 | getPossibleMovesFrom(sq) { | |
521 | const L = this.lastMoveEnd.length; | |
522 | if ( | |
523 | !!this.lastMoveEnd[L-1] && | |
524 | ( | |
525 | sq[0] != this.lastMoveEnd[L-1].x || | |
526 | sq[1] != this.lastMoveEnd[L-1].y | |
527 | ) | |
528 | ) { | |
529 | return []; | |
530 | } | |
531 | let moves = this.getPotentialMovesFrom(sq); | |
532 | const captureMoves = V.KeepCaptures(moves); | |
533 | if (captureMoves.length > 0) return captureMoves; | |
534 | if (this.atLeastOneCapture()) return []; | |
535 | return moves; | |
536 | } | |
537 | ||
538 | getAllValidMoves() { | |
539 | const moves = this.getAllPotentialMoves(); | |
540 | const captures = V.KeepCaptures(moves); | |
541 | if (captures.length > 0) return captures; | |
542 | return moves; | |
543 | } | |
544 | ||
545 | filterValid(moves) { | |
546 | // No checks | |
547 | return moves; | |
548 | } | |
549 | ||
550 | play(move) { | |
551 | this.epSquares.push(this.getEpSquare(move)); | |
552 | V.PlayOnBoard(this.board, move); | |
553 | if (move.vanish.length >= 2) { | |
554 | // Capture: update this.captured | |
555 | for (let i=1; i<move.vanish.length; i++) | |
556 | this.captured[move.vanish[i].c][move.vanish[i].p]++; | |
557 | } | |
7ddfec38 BA |
558 | // Check if the move is the last of the turn |
559 | if (move.vanish.length >= 2 || move.appear.length == 0) { | |
560 | const moreCaptures = ( | |
561 | V.KeepCaptures( | |
562 | this.getPotentialMovesFrom([move.end.x, move.end.y]) | |
563 | ) | |
564 | .length > 0 | |
565 | ); | |
566 | move.last = !moreCaptures; | |
567 | } | |
568 | else move.last = true; | |
6e47d367 BA |
569 | if (!!move.last) { |
570 | // No capture, or no more capture available | |
571 | this.turn = V.GetOppCol(this.turn); | |
572 | this.movesCount++; | |
573 | this.lastMoveEnd.push(null); | |
7ddfec38 | 574 | move.last = true; //will be used in undo and computer play |
6e47d367 BA |
575 | } |
576 | else this.lastMoveEnd.push(move.end); | |
577 | } | |
578 | ||
579 | undo(move) { | |
580 | this.epSquares.pop(); | |
581 | this.lastMoveEnd.pop(); | |
582 | V.UndoOnBoard(this.board, move); | |
583 | if (move.vanish.length >= 2) { | |
584 | for (let i=1; i<move.vanish.length; i++) | |
585 | this.captured[move.vanish[i].c][move.vanish[i].p]--; | |
586 | } | |
587 | if (!!move.last) { | |
588 | this.turn = V.GetOppCol(this.turn); | |
589 | this.movesCount--; | |
590 | } | |
591 | } | |
592 | ||
593 | getCheckSquares() { | |
594 | return []; | |
595 | } | |
596 | ||
597 | getCurrentScore() { | |
598 | // Count kings: if one is missing, the side lost | |
599 | let kingsCount = { 'w': 0, 'b': 0 }; | |
600 | for (let i=0; i<8; i++) { | |
601 | for (let j=0; j<8; j++) { | |
602 | if (this.board[i][j] != V.EMPTY && this.getPiece(i, j) == V.KING) | |
603 | kingsCount[this.getColor(i, j)]++; | |
604 | } | |
605 | } | |
606 | if (kingsCount['w'] < 2) return "0-1"; | |
607 | if (kingsCount['b'] < 2) return "1-0"; | |
608 | return "*"; | |
609 | } | |
610 | ||
611 | getComputerMove() { | |
612 | let moves = this.getAllValidMoves(); | |
613 | if (moves.length == 0) return null; | |
614 | // Just play random moves (for now at least. TODO?) | |
615 | let mvArray = []; | |
616 | while (moves.length > 0) { | |
617 | const mv = moves[randInt(moves.length)]; | |
618 | mvArray.push(mv); | |
7ddfec38 | 619 | this.play(mv); |
6e47d367 | 620 | if (!mv.last) { |
6e47d367 BA |
621 | moves = V.KeepCaptures( |
622 | this.getPotentialMovesFrom([mv.end.x, mv.end.y])); | |
623 | } | |
624 | else break; | |
625 | } | |
7ddfec38 | 626 | for (let i = mvArray.length - 1; i >= 0; i--) this.undo(mvArray[i]); |
6e47d367 BA |
627 | return (mvArray.length > 1 ? mvArray : mvArray[0]); |
628 | } | |
629 | ||
630 | getNotation(move) { | |
631 | const initialSquare = V.CoordsToSquare(move.start); | |
632 | const finalSquare = V.CoordsToSquare(move.end); | |
633 | if (move.appear.length == 0) | |
634 | // Remover captures 'R' | |
635 | return initialSquare + "R"; | |
636 | let notation = move.appear[0].p.toUpperCase() + finalSquare; | |
637 | // Add a capture mark (not describing what is captured...): | |
638 | if (move.vanish.length >= 2) notation += "X"; | |
639 | return notation; | |
640 | } | |
641 | }; |