Add Hypnotic + Mesmer variants
[vchess.git] / client / src / variants / Dynamo.js
... / ...
CommitLineData
1import { ChessRules, Move, PiPo } from "@/base_rules";
2import { randInt } from "@/utils/alea";
3
4export 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-r]{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 let isOpposite = La > 0 && this.oppositeMoves(this.amoves[La-1], m);
611 if (res || isOpposite) {
612 const moves2 = this.getAllPotentialMoves();
613 for (let m2 of moves2) {
614 this.play(m2);
615 const res2 = this.underCheck(color);
616 const amove = this.getAmove(m, m2);
617 isOpposite =
618 La > 0 && this.oppositeMoves(this.amoves[La-1], amove);
619 this.undo(m2);
620 if (!res2 && !isOpposite) {
621 res = false;
622 break;
623 }
624 }
625 }
626 this.undo(m);
627 return !res;
628 });
629 }
630 if (La == 0) return super.filterValid(moves);
631 const Lf = this.firstMove.length;
632 return (
633 super.filterValid(
634 moves.filter(m => {
635 // Move shouldn't undo another:
636 const amove = this.getAmove(this.firstMove[Lf-1], m);
637 return !this.oppositeMoves(this.amoves[La-1], amove);
638 })
639 )
640 );
641 }
642
643 isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) {
644 for (let step of steps) {
645 let rx = x + step[0],
646 ry = y + step[1];
647 while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) {
648 rx += step[0];
649 ry += step[1];
650 }
651 if (
652 V.OnBoard(rx, ry) &&
653 this.getPiece(rx, ry) == piece &&
654 this.getColor(rx, ry) == color
655 ) {
656 // Continue some steps in the same direction (pull)
657 rx += step[0];
658 ry += step[1];
659 while (
660 V.OnBoard(rx, ry) &&
661 this.board[rx][ry] == V.EMPTY &&
662 !oneStep
663 ) {
664 rx += step[0];
665 ry += step[1];
666 }
667 if (!V.OnBoard(rx, ry)) return true;
668 // Step in the other direction (push)
669 rx = x - step[0];
670 ry = y - step[1];
671 while (
672 V.OnBoard(rx, ry) &&
673 this.board[rx][ry] == V.EMPTY &&
674 !oneStep
675 ) {
676 rx -= step[0];
677 ry -= step[1];
678 }
679 if (!V.OnBoard(rx, ry)) return true;
680 }
681 }
682 return false;
683 }
684
685 isAttackedByPawn([x, y], color) {
686 // The king can be pushed out by a pawn on last rank or near the edge
687 const pawnShift = (color == "w" ? 1 : -1);
688 for (let i of [-1, 1]) {
689 if (
690 V.OnBoard(x + pawnShift, y + i) &&
691 this.board[x + pawnShift][y + i] != V.EMPTY &&
692 this.getPiece(x + pawnShift, y + i) == V.PAWN &&
693 this.getColor(x + pawnShift, y + i) == color
694 ) {
695 if (!V.OnBoard(x - pawnShift, y - i)) return true;
696 }
697 }
698 return false;
699 }
700
701 static OnTheEdge(x, y) {
702 return (x == 0 || x == 7 || y == 0 || y == 7);
703 }
704
705 isAttackedByKing([x, y], color) {
706 // Attacked if I'm on the edge and the opponent king just next,
707 // but not on the edge.
708 if (V.OnTheEdge(x, y)) {
709 for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
710 const [i, j] = [x + step[0], y + step[1]];
711 if (
712 V.OnBoard(i, j) &&
713 !V.OnTheEdge(i, j) &&
714 this.board[i][j] != V.EMPTY &&
715 this.getPiece(i, j) == V.KING
716 // NOTE: since only one king of each color, and (x, y) is occupied
717 // by our king, no need to check other king's color.
718 ) {
719 return true;
720 }
721 }
722 }
723 return false;
724 }
725
726 // No consideration of color: all pieces could be played
727 getAllPotentialMoves() {
728 let potentialMoves = [];
729 for (let i = 0; i < V.size.x; i++) {
730 for (let j = 0; j < V.size.y; j++) {
731 if (this.board[i][j] != V.EMPTY) {
732 Array.prototype.push.apply(
733 potentialMoves,
734 this.getPotentialMovesFrom([i, j])
735 );
736 }
737 }
738 }
739 return potentialMoves;
740 }
741
742 doClick(square) {
743 // A click to promote a piece on subTurn 2 would trigger this.
744 // For now it would then return [NaN, NaN] because surrounding squares
745 // have no IDs in the promotion modal. TODO: improve this?
746 if (isNaN(square[0])) return null;
747 // If subTurn == 2 && square is empty && !underCheck && !isOpposite,
748 // then return an empty move, allowing to "pass" subTurn2
749 const La = this.amoves.length;
750 const Lf = this.firstMove.length;
751 if (
752 this.subTurn == 2 &&
753 this.board[square[0]][square[1]] == V.EMPTY &&
754 !this.underCheck(this.turn) &&
755 (La == 0 || !this.oppositeMoves(this.amoves[La-1], this.firstMove[Lf-1]))
756 ) {
757 return {
758 start: { x: -1, y: -1 },
759 end: { x: -1, y: -1 },
760 appear: [],
761 vanish: []
762 };
763 }
764 return null;
765 }
766
767 play(move) {
768 move.flags = JSON.stringify(this.aggregateFlags());
769 V.PlayOnBoard(this.board, move);
770 // NOTE; if subTurn == 1, there may be no available moves at subTurn == 2.
771 // However, it's quite easier to wait for a user click.
772 if (this.subTurn == 2) {
773 const L = this.firstMove.length;
774 this.amoves.push(this.getAmove(this.firstMove[L-1], move));
775 this.turn = V.GetOppCol(this.turn);
776 this.movesCount++;
777 }
778 else this.firstMove.push(move);
779 this.subTurn = 3 - this.subTurn;
780 this.postPlay(move);
781 }
782
783 postPlay(move) {
784 if (move.start.x < 0) return;
785 for (let a of move.appear)
786 if (a.p == V.KING) this.kingPos[a.c] = [a.x, a.y];
787 this.updateCastleFlags(move);
788 }
789
790 updateCastleFlags(move) {
791 const firstRank = { 'w': V.size.x - 1, 'b': 0 };
792 for (let v of move.vanish) {
793 if (v.p == V.KING) this.castleFlags[v.c] = [V.size.y, V.size.y];
794 else if (v.x == firstRank[v.c] && this.castleFlags[v.c].includes(v.y)) {
795 const flagIdx = (v.y == this.castleFlags[v.c][0] ? 0 : 1);
796 this.castleFlags[v.c][flagIdx] = V.size.y;
797 }
798 }
799 }
800
801 undo(move) {
802 this.disaggregateFlags(JSON.parse(move.flags));
803 V.UndoOnBoard(this.board, move);
804 if (this.subTurn == 1) {
805 this.amoves.pop();
806 this.turn = V.GetOppCol(this.turn);
807 this.movesCount--;
808 }
809 else this.firstMove.pop();
810 this.subTurn = 3 - this.subTurn;
811 this.postUndo(move);
812 }
813
814 postUndo(move) {
815 // (Potentially) Reset king position
816 for (let v of move.vanish)
817 if (v.p == V.KING) this.kingPos[v.c] = [v.x, v.y];
818 }
819
820 getComputerMove() {
821 let moves = this.getAllValidMoves();
822 if (moves.length == 0) return null;
823 // "Search" at depth 1 for now
824 const maxeval = V.INFINITY;
825 const color = this.turn;
826 const emptyMove = {
827 start: { x: -1, y: -1 },
828 end: { x: -1, y: -1 },
829 appear: [],
830 vanish: []
831 };
832 moves.forEach(m => {
833 this.play(m);
834 m.eval = (color == "w" ? -1 : 1) * maxeval;
835 const moves2 = this.getAllValidMoves().concat([emptyMove]);
836 m.next = moves2[0];
837 moves2.forEach(m2 => {
838 this.play(m2);
839 const score = this.getCurrentScore();
840 let mvEval = 0;
841 if (score != "1/2") {
842 if (score != "*") mvEval = (score == "1-0" ? 1 : -1) * maxeval;
843 else mvEval = this.evalPosition();
844 }
845 if (
846 (color == 'w' && mvEval > m.eval) ||
847 (color == 'b' && mvEval < m.eval)
848 ) {
849 m.eval = mvEval;
850 m.next = m2;
851 }
852 this.undo(m2);
853 });
854 this.undo(m);
855 });
856 moves.sort((a, b) => {
857 return (color == "w" ? 1 : -1) * (b.eval - a.eval);
858 });
859 let candidates = [0];
860 for (let i = 1; i < moves.length && moves[i].eval == moves[0].eval; i++)
861 candidates.push(i);
862 const mIdx = candidates[randInt(candidates.length)];
863 const move2 = moves[mIdx].next;
864 delete moves[mIdx]["next"];
865 return [moves[mIdx], move2];
866 }
867
868 getNotation(move) {
869 if (move.start.x < 0)
870 // A second move is always required, but may be empty
871 return "-";
872 const initialSquare = V.CoordsToSquare(move.start);
873 const finalSquare = V.CoordsToSquare(move.end);
874 if (move.appear.length == 0)
875 // Pushed or pulled out of the board
876 return initialSquare + "R";
877 return move.appear[0].p.toUpperCase() + initialSquare + finalSquare;
878 }
879
880};