Pandemonium 1 & 2, Stealthbomb 1 & 2
[vchess.git] / client / src / variants / Dynamo.js
1 import { ChessRules, Move, PiPo } from "@/base_rules";
2 import { randInt } from "@/utils/alea";
3
4 export class DynamoRules extends ChessRules {
5
6 // TODO? later, allow to push out pawns on a and h files
7 static get HasEnpassant() {
8 return false;
9 }
10
11 canIplay(side, [x, y]) {
12 // Sometimes opponent's pieces can be moved directly
13 return this.turn == side;
14 }
15
16 setOtherVariables(fen) {
17 super.setOtherVariables(fen);
18 this.subTurn = 1;
19 // Local stack of "action moves"
20 this.amoves = [];
21 const amove = V.ParseFen(fen).amove;
22 if (amove != "-") {
23 const amoveParts = amove.split("/");
24 let move = {
25 // No need for start & end
26 appear: [],
27 vanish: []
28 };
29 [0, 1].map(i => {
30 if (amoveParts[i] != "-") {
31 amoveParts[i].split(".").forEach(av => {
32 // Format is "bpe3"
33 const xy = V.SquareToCoords(av.substr(2));
34 move[i == 0 ? "appear" : "vanish"].push(
35 new PiPo({
36 x: xy.x,
37 y: xy.y,
38 c: av[0],
39 p: av[1]
40 })
41 );
42 });
43 }
44 });
45 this.amoves.push(move);
46 }
47 // Stack "first moves" (on subTurn 1) to merge and check opposite moves
48 this.firstMove = [];
49 }
50
51 static ParseFen(fen) {
52 return Object.assign(
53 ChessRules.ParseFen(fen),
54 { amove: fen.split(" ")[4] }
55 );
56 }
57
58 static IsGoodFen(fen) {
59 if (!ChessRules.IsGoodFen(fen)) return false;
60 const fenParts = fen.split(" ");
61 if (fenParts.length != 5) return false;
62 if (fenParts[4] != "-") {
63 // TODO: a single regexp instead.
64 // Format is [bpa2[.wpd3]] || '-'/[bbc3[.wrd5]] || '-'
65 const amoveParts = fenParts[4].split("/");
66 if (amoveParts.length != 2) return false;
67 for (let part of amoveParts) {
68 if (part != "-") {
69 for (let psq of part.split("."))
70 if (!psq.match(/^[a-z]{3}[1-8]$/)) return false;
71 }
72 }
73 }
74 return true;
75 }
76
77 getFen() {
78 return super.getFen() + " " + this.getAmoveFen();
79 }
80
81 getFenForRepeat() {
82 return super.getFenForRepeat() + "_" + this.getAmoveFen();
83 }
84
85 getAmoveFen() {
86 const L = this.amoves.length;
87 if (L == 0) return "-";
88 return (
89 ["appear","vanish"].map(
90 mpart => {
91 if (this.amoves[L-1][mpart].length == 0) return "-";
92 return (
93 this.amoves[L-1][mpart].map(
94 av => {
95 const square = V.CoordsToSquare({ x: av.x, y: av.y });
96 return av.c + av.p + square;
97 }
98 ).join(".")
99 );
100 }
101 ).join("/")
102 );
103 }
104
105 canTake() {
106 // Captures don't occur (only pulls & pushes)
107 return false;
108 }
109
110 // Step is right, just add (push/pull) moves in this direction
111 // Direction is assumed normalized.
112 getMovesInDirection([x, y], [dx, dy], nbSteps) {
113 nbSteps = nbSteps || 8; //max 8 steps anyway
114 let [i, j] = [x + dx, y + dy];
115 let moves = [];
116 const color = this.getColor(x, y);
117 const piece = this.getPiece(x, y);
118 const lastRank = (color == 'w' ? 0 : 7);
119 let counter = 1;
120 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
121 if (i == lastRank && piece == V.PAWN) {
122 // Promotion by push or pull
123 V.PawnSpecs.promotions.forEach(p => {
124 let move = super.getBasicMove([x, y], [i, j], { c: color, p: p });
125 moves.push(move);
126 });
127 }
128 else moves.push(super.getBasicMove([x, y], [i, j]));
129 if (++counter > nbSteps) break;
130 i += dx;
131 j += dy;
132 }
133 if (!V.OnBoard(i, j) && piece != V.KING) {
134 // Add special "exit" move, by "taking king"
135 moves.push(
136 new Move({
137 start: { x: x, y: y },
138 end: { x: this.kingPos[color][0], y: this.kingPos[color][1] },
139 appear: [],
140 vanish: [{ x: x, y: y, c: color, p: piece }]
141 })
142 );
143 }
144 return moves;
145 }
146
147 // Normalize direction to know the step
148 getNormalizedDirection([dx, dy]) {
149 const absDir = [Math.abs(dx), Math.abs(dy)];
150 let divisor = 0;
151 if (absDir[0] != 0 && absDir[1] != 0 && absDir[0] != absDir[1])
152 // Knight
153 divisor = Math.min(absDir[0], absDir[1]);
154 else
155 // Standard slider (or maybe a pawn or king: same)
156 divisor = Math.max(absDir[0], absDir[1]);
157 return [dx / divisor, dy / divisor];
158 }
159
160 // There was something on x2,y2, maybe our color, pushed or (self)pulled
161 isAprioriValidExit([x1, y1], [x2, y2], color2, piece2) {
162 const color1 = this.getColor(x1, y1);
163 const pawnShift = (color1 == 'w' ? -1 : 1);
164 const lastRank = (color1 == 'w' ? 0 : 7);
165 const deltaX = Math.abs(x1 - x2);
166 const deltaY = Math.abs(y1 - y2);
167 const checkSlider = () => {
168 const dir = this.getNormalizedDirection([x2 - x1, y2 - y1]);
169 let [i, j] = [x1 + dir[0], y1 + dir[1]];
170 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
171 i += dir[0];
172 j += dir[1];
173 }
174 return !V.OnBoard(i, j);
175 };
176 switch (piece2 || this.getPiece(x1, y1)) {
177 case V.PAWN:
178 return (
179 x1 + pawnShift == x2 &&
180 (
181 (color1 == color2 && x2 == lastRank && y1 == y2) ||
182 (
183 color1 != color2 &&
184 deltaY == 1 &&
185 !V.OnBoard(2 * x2 - x1, 2 * y2 - y1)
186 )
187 )
188 );
189 case V.ROOK:
190 if (x1 != x2 && y1 != y2) return false;
191 return checkSlider();
192 case V.KNIGHT:
193 return (
194 deltaX + deltaY == 3 &&
195 (deltaX == 1 || deltaY == 1) &&
196 !V.OnBoard(2 * x2 - x1, 2 * y2 - y1)
197 );
198 case V.BISHOP:
199 if (deltaX != deltaY) return false;
200 return checkSlider();
201 case V.QUEEN:
202 if (deltaX != 0 && deltaY != 0 && deltaX != deltaY) return false;
203 return checkSlider();
204 case V.KING:
205 return (
206 deltaX <= 1 &&
207 deltaY <= 1 &&
208 !V.OnBoard(2 * x2 - x1, 2 * y2 - y1)
209 );
210 }
211 return false;
212 }
213
214 isAprioriValidVertical([x1, y1], x2) {
215 const piece = this.getPiece(x1, y1);
216 const deltaX = Math.abs(x1 - x2);
217 const startRank = (this.getColor(x1, y1) == 'w' ? 6 : 1);
218 return (
219 [V.QUEEN, V.ROOK].includes(piece) ||
220 (
221 [V.KING, V.PAWN].includes(piece) &&
222 (
223 deltaX == 1 ||
224 (deltaX == 2 && piece == V.PAWN && x1 == startRank)
225 )
226 )
227 );
228 }
229
230 // NOTE: for pushes, play the pushed piece first.
231 // for pulls: play the piece doing the action first
232 // NOTE: to push a piece out of the board, make it slide until its king
233 getPotentialMovesFrom([x, y]) {
234 const color = this.turn;
235 const sqCol = this.getColor(x, y);
236 const pawnShift = (color == 'w' ? -1 : 1);
237 const pawnStartRank = (color == 'w' ? 6 : 1);
238 const getMoveHash = (m) => {
239 return V.CoordsToSquare(m.start) + V.CoordsToSquare(m.end);
240 };
241 if (this.subTurn == 1) {
242 const addMoves = (dir, nbSteps) => {
243 const newMoves =
244 this.getMovesInDirection([x, y], [-dir[0], -dir[1]], nbSteps)
245 .filter(m => !movesHash[getMoveHash(m)]);
246 newMoves.forEach(m => { movesHash[getMoveHash(m)] = true; });
247 Array.prototype.push.apply(moves, newMoves);
248 };
249 // Free to play any move (if piece of my color):
250 let moves =
251 sqCol == color
252 ? super.getPotentialMovesFrom([x, y])
253 : [];
254 // There may be several suicide moves: keep only one
255 let hasExit = false;
256 moves = moves.filter(m => {
257 const suicide = (m.appear.length == 0);
258 if (suicide) {
259 if (hasExit) return false;
260 hasExit = true;
261 }
262 return true;
263 });
264 // Structure to avoid adding moves twice (can be action & move)
265 let movesHash = {};
266 moves.forEach(m => { movesHash[getMoveHash(m)] = true; });
267 // [x, y] is pushed by 'color'
268 for (let step of V.steps[V.KNIGHT]) {
269 const [i, j] = [x + step[0], y + step[1]];
270 if (
271 V.OnBoard(i, j) &&
272 this.board[i][j] != V.EMPTY &&
273 this.getColor(i, j) == color &&
274 this.getPiece(i, j) == V.KNIGHT
275 ) {
276 addMoves(step, 1);
277 }
278 }
279 for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
280 let [i, j] = [x + step[0], y + step[1]];
281 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
282 i += step[0];
283 j += step[1];
284 }
285 if (
286 V.OnBoard(i, j) &&
287 this.board[i][j] != V.EMPTY &&
288 this.getColor(i, j) == color
289 ) {
290 const deltaX = Math.abs(i - x);
291 const deltaY = Math.abs(j - y);
292 switch (this.getPiece(i, j)) {
293 case V.PAWN:
294 if (
295 (x - i) / deltaX == pawnShift &&
296 deltaX <= 2 &&
297 deltaY <= 1
298 ) {
299 if (sqCol == color && deltaY == 0) {
300 // Pushed forward
301 const maxSteps = (i == pawnStartRank && deltaX == 1 ? 2 : 1);
302 addMoves(step, maxSteps);
303 }
304 else if (sqCol != color && deltaY == 1 && deltaX == 1)
305 // Pushed diagonally
306 addMoves(step, 1);
307 }
308 break;
309 case V.ROOK:
310 if (deltaX == 0 || deltaY == 0) addMoves(step);
311 break;
312 case V.BISHOP:
313 if (deltaX == deltaY) addMoves(step);
314 break;
315 case V.QUEEN:
316 // All steps are valid for a queen:
317 addMoves(step);
318 break;
319 case V.KING:
320 if (deltaX <= 1 && deltaY <= 1) addMoves(step, 1);
321 break;
322 }
323 }
324 }
325 return moves;
326 }
327 // If subTurn == 2 then we should have a first move,
328 // which restrict what we can play now: only in the first move direction
329 const L = this.firstMove.length;
330 const fm = this.firstMove[L-1];
331 if (
332 (fm.appear.length == 2 && fm.vanish.length == 2) ||
333 (fm.vanish[0].c == sqCol && sqCol != color)
334 ) {
335 // Castle or again opponent color: no move playable then.
336 return [];
337 }
338 const piece = this.getPiece(x, y);
339 const getPushExit = () => {
340 // Piece at subTurn 1 exited: can I have caused the exit?
341 if (
342 this.isAprioriValidExit(
343 [x, y],
344 [fm.start.x, fm.start.y],
345 fm.vanish[0].c
346 )
347 ) {
348 // Seems so:
349 const dir = this.getNormalizedDirection(
350 [fm.start.x - x, fm.start.y - y]);
351 const nbSteps =
352 [V.PAWN, V.KING, V.KNIGHT].includes(piece)
353 ? 1
354 : null;
355 return this.getMovesInDirection([x, y], dir, nbSteps);
356 }
357 return [];
358 }
359 const getPushMoves = () => {
360 // Piece from subTurn 1 is still on board:
361 const dirM = this.getNormalizedDirection(
362 [fm.end.x - fm.start.x, fm.end.y - fm.start.y]);
363 const dir = this.getNormalizedDirection(
364 [fm.start.x - x, fm.start.y - y]);
365 // Normalized directions should match
366 if (dir[0] == dirM[0] && dir[1] == dirM[1]) {
367 // We don't know if first move is a pushed piece or normal move,
368 // so still must check if the push is valid.
369 const deltaX = Math.abs(fm.start.x - x);
370 const deltaY = Math.abs(fm.start.y - y);
371 switch (piece) {
372 case V.PAWN:
373 if (x == pawnStartRank) {
374 if (
375 (fm.start.x - x) * pawnShift < 0 ||
376 deltaX >= 3 ||
377 deltaY >= 2 ||
378 (fm.vanish[0].c == color && deltaY > 0) ||
379 (fm.vanish[0].c != color && deltaY == 0) ||
380 Math.abs(fm.end.x - fm.start.x) > deltaX ||
381 fm.end.y - fm.start.y != fm.start.y - y
382 ) {
383 return [];
384 }
385 }
386 else {
387 if (
388 fm.start.x - x != pawnShift ||
389 deltaY >= 2 ||
390 (fm.vanish[0].c == color && deltaY == 1) ||
391 (fm.vanish[0].c != color && deltaY == 0) ||
392 fm.end.x - fm.start.x != pawnShift ||
393 fm.end.y - fm.start.y != fm.start.y - y
394 ) {
395 return [];
396 }
397 }
398 break;
399 case V.KNIGHT:
400 if (
401 (deltaX + deltaY != 3 || (deltaX == 0 && deltaY == 0)) ||
402 (fm.end.x - fm.start.x != fm.start.x - x) ||
403 (fm.end.y - fm.start.y != fm.start.y - y)
404 ) {
405 return [];
406 }
407 break;
408 case V.KING:
409 if (
410 (deltaX >= 2 || deltaY >= 2) ||
411 (fm.end.x - fm.start.x != fm.start.x - x) ||
412 (fm.end.y - fm.start.y != fm.start.y - y)
413 ) {
414 return [];
415 }
416 break;
417 case V.BISHOP:
418 if (deltaX != deltaY) return [];
419 break;
420 case V.ROOK:
421 if (deltaX != 0 && deltaY != 0) return [];
422 break;
423 case V.QUEEN:
424 if (deltaX != deltaY && deltaX != 0 && deltaY != 0) return [];
425 break;
426 }
427 // Nothing should stand between [x, y] and the square fm.start
428 let [i, j] = [x + dir[0], y + dir[1]];
429 while (
430 (i != fm.start.x || j != fm.start.y) &&
431 this.board[i][j] == V.EMPTY
432 ) {
433 i += dir[0];
434 j += dir[1];
435 }
436 if (i == fm.start.x && j == fm.start.y)
437 return this.getMovesInDirection([x, y], dir);
438 }
439 return [];
440 }
441 const getPullExit = () => {
442 // Piece at subTurn 1 exited: can I be pulled?
443 // Note: kings cannot suicide, so fm.vanish[0].p is not KING.
444 // Could be PAWN though, if a pawn was pushed out of board.
445 if (
446 fm.vanish[0].p != V.PAWN && //pawns cannot pull
447 this.isAprioriValidExit(
448 [x, y],
449 [fm.start.x, fm.start.y],
450 fm.vanish[0].c,
451 fm.vanish[0].p
452 )
453 ) {
454 // Seems so:
455 const dir = this.getNormalizedDirection(
456 [fm.start.x - x, fm.start.y - y]);
457 const nbSteps = (fm.vanish[0].p == V.KNIGHT ? 1 : null);
458 return this.getMovesInDirection([x, y], dir, nbSteps);
459 }
460 return [];
461 };
462 const getPullMoves = () => {
463 if (fm.vanish[0].p == V.PAWN)
464 // pawns cannot pull
465 return [];
466 const dirM = this.getNormalizedDirection(
467 [fm.end.x - fm.start.x, fm.end.y - fm.start.y]);
468 const dir = this.getNormalizedDirection(
469 [fm.start.x - x, fm.start.y - y]);
470 // Normalized directions should match
471 if (dir[0] == dirM[0] && dir[1] == dirM[1]) {
472 // Am I at the right distance?
473 const deltaX = Math.abs(x - fm.start.x);
474 const deltaY = Math.abs(y - fm.start.y);
475 if (
476 (fm.vanish[0].p == V.KING && (deltaX > 1 || deltaY > 1)) ||
477 (fm.vanish[0].p == V.KNIGHT &&
478 (deltaX + deltaY != 3 || deltaX == 0 || deltaY == 0))
479 ) {
480 return [];
481 }
482 // Nothing should stand between [x, y] and the square fm.start
483 let [i, j] = [x + dir[0], y + dir[1]];
484 while (
485 (i != fm.start.x || j != fm.start.y) &&
486 this.board[i][j] == V.EMPTY
487 ) {
488 i += dir[0];
489 j += dir[1];
490 }
491 if (i == fm.start.x && j == fm.start.y)
492 return this.getMovesInDirection([x, y], dir);
493 }
494 return [];
495 };
496 if (fm.vanish[0].c != color) {
497 // Only possible action is a push:
498 if (fm.appear.length == 0) return getPushExit();
499 return getPushMoves();
500 }
501 else if (sqCol != color) {
502 // Only possible action is a pull, considering moving piece abilities
503 if (fm.appear.length == 0) return getPullExit();
504 return getPullMoves();
505 }
506 else {
507 // My color + my color: both actions possible
508 // Structure to avoid adding moves twice (can be action & move)
509 let movesHash = {};
510 if (fm.appear.length == 0) {
511 const pushes = getPushExit();
512 pushes.forEach(m => { movesHash[getMoveHash(m)] = true; });
513 return (
514 pushes.concat(getPullExit().filter(m => !movesHash[getMoveHash(m)]))
515 );
516 }
517 const pushes = getPushMoves();
518 pushes.forEach(m => { movesHash[getMoveHash(m)] = true; });
519 return (
520 pushes.concat(getPullMoves().filter(m => !movesHash[getMoveHash(m)]))
521 );
522 }
523 return [];
524 }
525
526 getSlideNJumpMoves([x, y], steps, oneStep) {
527 let moves = [];
528 const c = this.getColor(x, y);
529 const piece = this.getPiece(x, y);
530 outerLoop: for (let step of steps) {
531 let i = x + step[0];
532 let j = y + step[1];
533 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
534 moves.push(this.getBasicMove([x, y], [i, j]));
535 if (oneStep) continue outerLoop;
536 i += step[0];
537 j += step[1];
538 }
539 if (V.OnBoard(i, j)) {
540 if (this.canTake([x, y], [i, j]))
541 moves.push(this.getBasicMove([x, y], [i, j]));
542 }
543 else {
544 // Add potential board exit (suicide), except for the king
545 if (piece != V.KING) {
546 moves.push({
547 start: { x: x, y: y},
548 end: { x: this.kingPos[c][0], y: this.kingPos[c][1] },
549 appear: [],
550 vanish: [
551 new PiPo({
552 x: x,
553 y: y,
554 c: c,
555 p: piece
556 })
557 ]
558 });
559 }
560 }
561 }
562 return moves;
563 }
564
565 // Does m2 un-do m1 ? (to disallow undoing actions)
566 oppositeMoves(m1, m2) {
567 const isEqual = (av1, av2) => {
568 for (let av of av1) {
569 const avInAv2 = av2.find(elt => {
570 return (
571 elt.x == av.x &&
572 elt.y == av.y &&
573 elt.c == av.c &&
574 elt.p == av.p
575 );
576 });
577 if (!avInAv2) return false;
578 }
579 return true;
580 };
581 // All appear and vanish arrays must have the same length
582 const mL = m1.appear.length;
583 return (
584 m2.appear.length == mL &&
585 m1.vanish.length == mL &&
586 m2.vanish.length == mL &&
587 isEqual(m1.appear, m2.vanish) &&
588 isEqual(m1.vanish, m2.appear)
589 );
590 }
591
592 getAmove(move1, move2) {
593 // Just merge (one is action one is move, one may be empty)
594 return {
595 appear: move1.appear.concat(move2.appear),
596 vanish: move1.vanish.concat(move2.vanish)
597 }
598 }
599
600 filterValid(moves) {
601 const color = this.turn;
602 const La = this.amoves.length;
603 if (this.subTurn == 1) {
604 return moves.filter(m => {
605 // A move is valid either if it doesn't result in a check,
606 // or if a second move is possible to counter the check
607 // (not undoing a potential move + action of the opponent)
608 this.play(m);
609 let res = this.underCheck(color);
610 if (this.subTurn == 2) {
611 let isOpposite = La > 0 && this.oppositeMoves(this.amoves[La-1], m);
612 if (res || isOpposite) {
613 const moves2 = this.getAllPotentialMoves();
614 for (let m2 of moves2) {
615 this.play(m2);
616 const res2 = this.underCheck(color);
617 const amove = this.getAmove(m, m2);
618 isOpposite =
619 La > 0 && this.oppositeMoves(this.amoves[La-1], amove);
620 this.undo(m2);
621 if (!res2 && !isOpposite) {
622 res = false;
623 break;
624 }
625 }
626 }
627 }
628 this.undo(m);
629 return !res;
630 });
631 }
632 if (La == 0) return super.filterValid(moves);
633 const Lf = this.firstMove.length;
634 return (
635 super.filterValid(
636 moves.filter(m => {
637 // Move shouldn't undo another:
638 const amove = this.getAmove(this.firstMove[Lf-1], m);
639 return !this.oppositeMoves(this.amoves[La-1], amove);
640 })
641 )
642 );
643 }
644
645 isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) {
646 for (let step of steps) {
647 let rx = x + step[0],
648 ry = y + step[1];
649 while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) {
650 rx += step[0];
651 ry += step[1];
652 }
653 if (
654 V.OnBoard(rx, ry) &&
655 this.getPiece(rx, ry) == piece &&
656 this.getColor(rx, ry) == color
657 ) {
658 // Continue some steps in the same direction (pull)
659 rx += step[0];
660 ry += step[1];
661 while (
662 V.OnBoard(rx, ry) &&
663 this.board[rx][ry] == V.EMPTY &&
664 !oneStep
665 ) {
666 rx += step[0];
667 ry += step[1];
668 }
669 if (!V.OnBoard(rx, ry)) return true;
670 // Step in the other direction (push)
671 rx = x - step[0];
672 ry = y - step[1];
673 while (
674 V.OnBoard(rx, ry) &&
675 this.board[rx][ry] == V.EMPTY &&
676 !oneStep
677 ) {
678 rx -= step[0];
679 ry -= step[1];
680 }
681 if (!V.OnBoard(rx, ry)) return true;
682 }
683 }
684 return false;
685 }
686
687 isAttackedByPawn([x, y], color) {
688 // The king can be pushed out by a pawn on last rank or near the edge
689 const pawnShift = (color == "w" ? 1 : -1);
690 for (let i of [-1, 1]) {
691 if (
692 V.OnBoard(x + pawnShift, y + i) &&
693 this.board[x + pawnShift][y + i] != V.EMPTY &&
694 this.getPiece(x + pawnShift, y + i) == V.PAWN &&
695 this.getColor(x + pawnShift, y + i) == color
696 ) {
697 if (!V.OnBoard(x - pawnShift, y - i)) return true;
698 }
699 }
700 return false;
701 }
702
703 static OnTheEdge(x, y) {
704 return (x == 0 || x == 7 || y == 0 || y == 7);
705 }
706
707 isAttackedByKing([x, y], color) {
708 // Attacked if I'm on the edge and the opponent king just next,
709 // but not on the edge.
710 if (V.OnTheEdge(x, y)) {
711 for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
712 const [i, j] = [x + step[0], y + step[1]];
713 if (
714 V.OnBoard(i, j) &&
715 !V.OnTheEdge(i, j) &&
716 this.board[i][j] != V.EMPTY &&
717 this.getPiece(i, j) == V.KING
718 // NOTE: since only one king of each color, and (x, y) is occupied
719 // by our king, no need to check other king's color.
720 ) {
721 return true;
722 }
723 }
724 }
725 return false;
726 }
727
728 // No consideration of color: all pieces could be played
729 getAllPotentialMoves() {
730 let potentialMoves = [];
731 for (let i = 0; i < V.size.x; i++) {
732 for (let j = 0; j < V.size.y; j++) {
733 if (this.board[i][j] != V.EMPTY) {
734 Array.prototype.push.apply(
735 potentialMoves,
736 this.getPotentialMovesFrom([i, j])
737 );
738 }
739 }
740 }
741 return potentialMoves;
742 }
743
744 getEmptyMove() {
745 return new Move({
746 start: { x: -1, y: -1 },
747 end: { x: -1, y: -1 },
748 appear: [],
749 vanish: []
750 });
751 }
752
753 doClick(square) {
754 // A click to promote a piece on subTurn 2 would trigger this.
755 // For now it would then return [NaN, NaN] because surrounding squares
756 // have no IDs in the promotion modal. TODO: improve this?
757 if (isNaN(square[0])) return null;
758 // If subTurn == 2 && square is empty && !underCheck && !isOpposite,
759 // then return an empty move, allowing to "pass" subTurn2
760 const La = this.amoves.length;
761 const Lf = this.firstMove.length;
762 if (
763 this.subTurn == 2 &&
764 this.board[square[0]][square[1]] == V.EMPTY &&
765 !this.underCheck(this.turn) &&
766 (La == 0 || !this.oppositeMoves(this.amoves[La-1], this.firstMove[Lf-1]))
767 ) {
768 return this.getEmptyMove();
769 }
770 return null;
771 }
772
773 play(move) {
774 if (this.subTurn == 1 && move.vanish.length == 0) {
775 // Patch to work with old format: (TODO: remove later)
776 move.ignore = true;
777 return;
778 }
779 const color = this.turn;
780 move.subTurn = this.subTurn; //for undo
781 const gotoNext = (mv) => {
782 const L = this.firstMove.length;
783 this.amoves.push(this.getAmove(this.firstMove[L-1], mv));
784 this.turn = V.GetOppCol(color);
785 this.subTurn = 1;
786 this.movesCount++;
787 };
788 move.flags = JSON.stringify(this.aggregateFlags());
789 V.PlayOnBoard(this.board, move);
790 if (this.subTurn == 2) gotoNext(move);
791 else {
792 this.subTurn = 2;
793 this.firstMove.push(move);
794 this.toNewKingPos(move);
795 if (
796 // Condition is true on empty arrays:
797 this.getAllPotentialMoves().every(m => {
798 V.PlayOnBoard(this.board, m);
799 this.toNewKingPos(m);
800 const res = this.underCheck(color);
801 V.UndoOnBoard(this.board, m);
802 this.toOldKingPos(m);
803 return res;
804 })
805 ) {
806 // No valid move at subTurn 2
807 gotoNext(this.getEmptyMove());
808 }
809 this.toOldKingPos(move);
810 }
811 this.postPlay(move);
812 }
813
814 toNewKingPos(move) {
815 for (let a of move.appear)
816 if (a.p == V.KING) this.kingPos[a.c] = [a.x, a.y];
817 }
818
819 postPlay(move) {
820 if (move.start.x < 0) return;
821 this.toNewKingPos(move);
822 this.updateCastleFlags(move);
823 }
824
825 updateCastleFlags(move) {
826 const firstRank = { 'w': V.size.x - 1, 'b': 0 };
827 for (let v of move.vanish) {
828 if (v.p == V.KING) this.castleFlags[v.c] = [V.size.y, V.size.y];
829 else if (v.x == firstRank[v.c] && this.castleFlags[v.c].includes(v.y)) {
830 const flagIdx = (v.y == this.castleFlags[v.c][0] ? 0 : 1);
831 this.castleFlags[v.c][flagIdx] = V.size.y;
832 }
833 }
834 }
835
836 undo(move) {
837 if (!!move.ignore) return; //TODO: remove that later
838 this.disaggregateFlags(JSON.parse(move.flags));
839 V.UndoOnBoard(this.board, move);
840 if (this.subTurn == 1) {
841 this.amoves.pop();
842 this.turn = V.GetOppCol(this.turn);
843 this.movesCount--;
844 }
845 if (move.subTurn == 1) this.firstMove.pop();
846 this.subTurn = move.subTurn;
847 this.toOldKingPos(move);
848 }
849
850 toOldKingPos(move) {
851 // (Potentially) Reset king position
852 for (let v of move.vanish)
853 if (v.p == V.KING) this.kingPos[v.c] = [v.x, v.y];
854 }
855
856 getComputerMove() {
857 let moves = this.getAllValidMoves();
858 if (moves.length == 0) return null;
859 // "Search" at depth 1 for now
860 const maxeval = V.INFINITY;
861 const color = this.turn;
862 const emptyMove = {
863 start: { x: -1, y: -1 },
864 end: { x: -1, y: -1 },
865 appear: [],
866 vanish: []
867 };
868 moves.forEach(m => {
869 this.play(m);
870 if (this.turn != color) m.eval = this.evalPosition();
871 else {
872 m.eval = (color == "w" ? -1 : 1) * maxeval;
873 const moves2 = this.getAllValidMoves().concat([emptyMove]);
874 m.next = moves2[0];
875 moves2.forEach(m2 => {
876 this.play(m2);
877 const score = this.getCurrentScore();
878 let mvEval = 0;
879 if (score != "1/2") {
880 if (score != "*") mvEval = (score == "1-0" ? 1 : -1) * maxeval;
881 else mvEval = this.evalPosition();
882 }
883 if (
884 (color == 'w' && mvEval > m.eval) ||
885 (color == 'b' && mvEval < m.eval)
886 ) {
887 m.eval = mvEval;
888 m.next = m2;
889 }
890 this.undo(m2);
891 });
892 }
893 this.undo(m);
894 });
895 moves.sort((a, b) => {
896 return (color == "w" ? 1 : -1) * (b.eval - a.eval);
897 });
898 let candidates = [0];
899 for (let i = 1; i < moves.length && moves[i].eval == moves[0].eval; i++)
900 candidates.push(i);
901 const mIdx = candidates[randInt(candidates.length)];
902 if (!moves[mIdx].next) return moves[mIdx];
903 const move2 = moves[mIdx].next;
904 delete moves[mIdx]["next"];
905 return [moves[mIdx], move2];
906 }
907
908 getNotation(move) {
909 if (move.start.x < 0)
910 // A second move is always required, but may be empty
911 return "-";
912 const initialSquare = V.CoordsToSquare(move.start);
913 const finalSquare = V.CoordsToSquare(move.end);
914 if (move.appear.length == 0)
915 // Pushed or pulled out of the board
916 return initialSquare + "R";
917 return move.appear[0].p.toUpperCase() + initialSquare + finalSquare;
918 }
919
920 };