Add temporary patch for preset challenges
[vchess.git] / client / src / variants / Dynamo.js
CommitLineData
b866a62a 1import { ChessRules, Move, PiPo } from "@/base_rules";
ad1e629e 2import { randInt } from "@/utils/alea";
b866a62a 3
0d5335de 4export class DynamoRules extends ChessRules {
7e8a7ea1 5
becbc692 6 // TODO? later, allow to push out pawns on a and h files
61656127
BA
7 static get HasEnpassant() {
8 return false;
9 }
10
c7550017
BA
11 canIplay(side, [x, y]) {
12 // Sometimes opponent's pieces can be moved directly
e78633db 13 return this.turn == side;
c7550017
BA
14 }
15
61656127
BA
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;
93ce6119 22 if (amove != "-") {
61656127 23 const amoveParts = amove.split("/");
ad1e629e 24 let move = {
61656127
BA
25 // No need for start & end
26 appear: [],
27 vanish: []
28 };
29 [0, 1].map(i => {
ad1e629e
BA
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 }
61656127
BA
44 });
45 this.amoves.push(move);
c7550017 46 }
a443d256
BA
47 // Stack "first moves" (on subTurn 1) to merge and check opposite moves
48 this.firstMove = [];
c7550017
BA
49 }
50
61656127
BA
51 static ParseFen(fen) {
52 return Object.assign(
53 ChessRules.ParseFen(fen),
93ce6119 54 { amove: fen.split(" ")[4] }
61656127
BA
55 );
56 }
57
58 static IsGoodFen(fen) {
59 if (!ChessRules.IsGoodFen(fen)) return false;
60 const fenParts = fen.split(" ");
ad1e629e
BA
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("."))
6980d66b 70 if (!psq.match(/^[a-z]{3}[1-8]$/)) return false;
ad1e629e
BA
71 }
72 }
73 }
61656127
BA
74 return true;
75 }
76
93ce6119
BA
77 getFen() {
78 return super.getFen() + " " + this.getAmoveFen();
61656127
BA
79 }
80
93ce6119
BA
81 getFenForRepeat() {
82 return super.getFenForRepeat() + "_" + this.getAmoveFen();
83 }
84
85 getAmoveFen() {
86 const L = this.amoves.length;
7b53b5a7 87 if (L == 0) return "-";
93ce6119
BA
88 return (
89 ["appear","vanish"].map(
90 mpart => {
156986e6 91 if (this.amoves[L-1][mpart].length == 0) return "-";
93ce6119
BA
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 );
61656127
BA
103 }
104
105 canTake() {
106 // Captures don't occur (only pulls & pushes)
107 return false;
108 }
109
b2655276
BA
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];
61656127 115 let moves = [];
b2655276
BA
116 const color = this.getColor(x, y);
117 const piece = this.getPiece(x, y);
118 const lastRank = (color == 'w' ? 0 : 7);
7b53b5a7 119 let counter = 1;
b2655276
BA
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]));
7b53b5a7
BA
129 if (++counter > nbSteps) break;
130 i += dx;
131 j += dy;
b2655276
BA
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 },
7b53b5a7 138 end: { x: this.kingPos[color][0], y: this.kingPos[color][1] },
b2655276
BA
139 appear: [],
140 vanish: [{ x: x, y: y, c: color, p: piece }]
141 })
142 );
143 }
61656127
BA
144 return moves;
145 }
146
b2655276
BA
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
becbc692
BA
160 // There was something on x2,y2, maybe our color, pushed or (self)pulled
161 isAprioriValidExit([x1, y1], [x2, y2], color2, piece2) {
b2655276 162 const color1 = this.getColor(x1, y1);
b2655276 163 const pawnShift = (color1 == 'w' ? -1 : 1);
ad1e629e 164 const lastRank = (color1 == 'w' ? 0 : 7);
b2655276
BA
165 const deltaX = Math.abs(x1 - x2);
166 const deltaY = Math.abs(y1 - y2);
ad1e629e
BA
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 };
becbc692 176 switch (piece2 || this.getPiece(x1, y1)) {
b2655276
BA
177 case V.PAWN:
178 return (
ad1e629e 179 x1 + pawnShift == x2 &&
b2655276 180 (
ad1e629e 181 (color1 == color2 && x2 == lastRank && y1 == y2) ||
becbc692
BA
182 (
183 color1 != color2 &&
184 deltaY == 1 &&
185 !V.OnBoard(2 * x2 - x1, 2 * y2 - y1)
186 )
b2655276
BA
187 )
188 );
189 case V.ROOK:
ad1e629e
BA
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 );
b2655276 198 case V.BISHOP:
ad1e629e
BA
199 if (deltaX != deltaY) return false;
200 return checkSlider();
b2655276 201 case V.QUEEN:
ad1e629e
BA
202 if (deltaX != 0 && deltaY != 0 && deltaX != deltaY) return false;
203 return checkSlider();
204 case V.KING:
b2655276 205 return (
ad1e629e
BA
206 deltaX <= 1 &&
207 deltaY <= 1 &&
208 !V.OnBoard(2 * x2 - x1, 2 * y2 - y1)
b2655276 209 );
93ce6119 210 }
b2655276 211 return false;
b866a62a
BA
212 }
213
05d37cc7
BA
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
93ce6119 230 // NOTE: for pushes, play the pushed piece first.
61656127 231 // for pulls: play the piece doing the action first
b2655276 232 // NOTE: to push a piece out of the board, make it slide until its king
b866a62a
BA
233 getPotentialMovesFrom([x, y]) {
234 const color = this.turn;
81e74ee5 235 const sqCol = this.getColor(x, y);
becbc692
BA
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 };
93ce6119 241 if (this.subTurn == 1) {
b2655276
BA
242 const addMoves = (dir, nbSteps) => {
243 const newMoves =
244 this.getMovesInDirection([x, y], [-dir[0], -dir[1]], nbSteps)
245 .filter(m => !movesHash[getMoveHash(m)]);
7b53b5a7 246 newMoves.forEach(m => { movesHash[getMoveHash(m)] = true; });
b2655276
BA
247 Array.prototype.push.apply(moves, newMoves);
248 };
8c267d0c 249 // Free to play any move (if piece of my color):
cfceecba 250 let moves =
81e74ee5 251 sqCol == color
8c267d0c
BA
252 ? super.getPotentialMovesFrom([x, y])
253 : [];
cfceecba
BA
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 });
7b53b5a7
BA
264 // Structure to avoid adding moves twice (can be action & move)
265 let movesHash = {};
266 moves.forEach(m => { movesHash[getMoveHash(m)] = true; });
b2655276
BA
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]];
7b53b5a7
BA
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);
b2655276
BA
277 }
278 }
7b53b5a7 279 for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
b2655276
BA
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);
b2655276
BA
292 switch (this.getPiece(i, j)) {
293 case V.PAWN:
ad1e629e
BA
294 if (
295 (x - i) / deltaX == pawnShift &&
296 deltaX <= 2 &&
297 deltaY <= 1
298 ) {
81e74ee5 299 if (sqCol == color && deltaY == 0) {
b2655276
BA
300 // Pushed forward
301 const maxSteps = (i == pawnStartRank && deltaX == 1 ? 2 : 1);
302 addMoves(step, maxSteps);
303 }
81e74ee5 304 else if (sqCol != color && deltaY == 1 && deltaX == 1)
b2655276
BA
305 // Pushed diagonally
306 addMoves(step, 1);
307 }
308 break;
309 case V.ROOK:
310 if (deltaX == 0 || deltaY == 0) addMoves(step);
311 break;
b2655276
BA
312 case V.BISHOP:
313 if (deltaX == deltaY) addMoves(step);
314 break;
315 case V.QUEEN:
cfceecba
BA
316 // All steps are valid for a queen:
317 addMoves(step);
b2655276
BA
318 break;
319 case V.KING:
320 if (deltaX <= 1 && deltaY <= 1) addMoves(step, 1);
321 break;
322 }
323 }
324 }
325 return moves;
b866a62a 326 }
93ce6119 327 // If subTurn == 2 then we should have a first move,
b2655276 328 // which restrict what we can play now: only in the first move direction
93ce6119
BA
329 const L = this.firstMove.length;
330 const fm = this.firstMove[L-1];
81e74ee5
BA
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.
b2655276 336 return [];
81e74ee5 337 }
becbc692
BA
338 const piece = this.getPiece(x, y);
339 const getPushExit = () => {
340 // Piece at subTurn 1 exited: can I have caused the exit?
ad1e629e
BA
341 if (
342 this.isAprioriValidExit(
343 [x, y],
344 [fm.start.x, fm.start.y],
345 fm.vanish[0].c
346 )
347 ) {
b2655276
BA
348 // Seems so:
349 const dir = this.getNormalizedDirection(
350 [fm.start.x - x, fm.start.y - y]);
6e0c0bcb 351 const nbSteps =
becbc692
BA
352 [V.PAWN, V.KING, V.KNIGHT].includes(piece)
353 ? 1
354 : null;
6e0c0bcb 355 return this.getMovesInDirection([x, y], dir, nbSteps);
b2655276 356 }
becbc692 357 return [];
93ce6119 358 }
becbc692
BA
359 const getPushMoves = () => {
360 // Piece from subTurn 1 is still on board:
b2655276
BA
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]);
ad1e629e
BA
365 // Normalized directions should match
366 if (dir[0] == dirM[0] && dir[1] == dirM[1]) {
becbc692
BA
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?
08ccbb78
BA
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.
becbc692 445 if (
08ccbb78 446 fm.vanish[0].p != V.PAWN && //pawns cannot pull
becbc692
BA
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);
05d37cc7 475 if (
becbc692
BA
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))
05d37cc7
BA
479 ) {
480 return [];
481 }
becbc692 482 // Nothing should stand between [x, y] and the square fm.start
ad1e629e
BA
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 }
becbc692
BA
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 );
93ce6119 522 }
b2655276 523 return [];
61656127
BA
524 }
525
cfceecba
BA
526 getSlideNJumpMoves([x, y], steps, oneStep) {
527 let moves = [];
81e74ee5
BA
528 const c = this.getColor(x, y);
529 const piece = this.getPiece(x, y);
cfceecba
BA
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
cfceecba 545 if (piece != V.KING) {
cfceecba
BA
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
61656127
BA
565 // Does m2 un-do m1 ? (to disallow undoing actions)
566 oppositeMoves(m1, m2) {
567 const isEqual = (av1, av2) => {
61656127
BA
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 };
266fba4a
BA
581 // All appear and vanish arrays must have the same length
582 const mL = m1.appear.length;
61656127 583 return (
266fba4a
BA
584 m2.appear.length == mL &&
585 m1.vanish.length == mL &&
586 m2.vanish.length == mL &&
61656127
BA
587 isEqual(m1.appear, m2.vanish) &&
588 isEqual(m1.vanish, m2.appear)
589 );
590 }
591
93ce6119
BA
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
61656127 600 filterValid(moves) {
93ce6119 601 const color = this.turn;
2e29e0e3 602 const La = this.amoves.length;
93ce6119
BA
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);
6980d66b
BA
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 }
93ce6119
BA
625 }
626 }
627 }
628 this.undo(m);
629 return !res;
630 });
631 }
93ce6119 632 if (La == 0) return super.filterValid(moves);
08ccbb78 633 const Lf = this.firstMove.length;
a443d256 634 return (
93ce6119 635 super.filterValid(
a443d256
BA
636 moves.filter(m => {
637 // Move shouldn't undo another:
93ce6119
BA
638 const amove = this.getAmove(this.firstMove[Lf-1], m);
639 return !this.oppositeMoves(this.amoves[La-1], amove);
a443d256
BA
640 })
641 )
642 );
b866a62a
BA
643 }
644
c7550017
BA
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 ) {
8c267d0c
BA
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)
c7550017
BA
671 rx = x - step[0];
672 ry = y - step[1];
2c5d7b20
BA
673 while (
674 V.OnBoard(rx, ry) &&
675 this.board[rx][ry] == V.EMPTY &&
676 !oneStep
677 ) {
c7550017
BA
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) {
becbc692 688 // The king can be pushed out by a pawn on last rank or near the edge
c7550017
BA
689 const pawnShift = (color == "w" ? 1 : -1);
690 for (let i of [-1, 1]) {
691 if (
08ccbb78
BA
692 V.OnBoard(x + pawnShift, y + i) &&
693 this.board[x + pawnShift][y + i] != V.EMPTY &&
c7550017
BA
694 this.getPiece(x + pawnShift, y + i) == V.PAWN &&
695 this.getColor(x + pawnShift, y + i) == color
696 ) {
08ccbb78
BA
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 }
c7550017
BA
723 }
724 }
725 return false;
726 }
61656127 727
156986e6
BA
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
9aeba28a
BA
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
93ce6119 753 doClick(square) {
becbc692
BA
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?
107dc1bd 757 if (isNaN(square[0])) return null;
2e29e0e3 758 // If subTurn == 2 && square is empty && !underCheck && !isOpposite,
b2655276 759 // then return an empty move, allowing to "pass" subTurn2
2e29e0e3
BA
760 const La = this.amoves.length;
761 const Lf = this.firstMove.length;
93ce6119
BA
762 if (
763 this.subTurn == 2 &&
7b53b5a7 764 this.board[square[0]][square[1]] == V.EMPTY &&
2e29e0e3
BA
765 !this.underCheck(this.turn) &&
766 (La == 0 || !this.oppositeMoves(this.amoves[La-1], this.firstMove[Lf-1]))
93ce6119 767 ) {
9aeba28a 768 return this.getEmptyMove();
93ce6119
BA
769 }
770 return null;
771 }
772
61656127 773 play(move) {
a1e392e6
BA
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 }
9aeba28a
BA
779 const color = this.turn;
780 move.subTurn = this.subTurn; //for undo
781 const gotoNext = (mv) => {
7b53b5a7 782 const L = this.firstMove.length;
9aeba28a
BA
783 this.amoves.push(this.getAmove(this.firstMove[L-1], mv));
784 this.turn = V.GetOppCol(color);
785 this.subTurn = 1;
7ddfec38 786 this.movesCount++;
9aeba28a
BA
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);
61656127
BA
810 }
811 this.postPlay(move);
812 }
813
9aeba28a 814 toNewKingPos(move) {
7b53b5a7
BA
815 for (let a of move.appear)
816 if (a.p == V.KING) this.kingPos[a.c] = [a.x, a.y];
9aeba28a
BA
817 }
818
819 postPlay(move) {
820 if (move.start.x < 0) return;
821 this.toNewKingPos(move);
7b53b5a7
BA
822 this.updateCastleFlags(move);
823 }
824
825 updateCastleFlags(move) {
826 const firstRank = { 'w': V.size.x - 1, 'b': 0 };
7ddfec38 827 for (let v of move.vanish) {
7b53b5a7
BA
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;
7ddfec38 832 }
61656127
BA
833 }
834 }
835
836 undo(move) {
a1e392e6 837 if (!!move.ignore) return; //TODO: remove that later
61656127
BA
838 this.disaggregateFlags(JSON.parse(move.flags));
839 V.UndoOnBoard(this.board, move);
7ddfec38 840 if (this.subTurn == 1) {
2e29e0e3 841 this.amoves.pop();
61656127 842 this.turn = V.GetOppCol(this.turn);
7ddfec38 843 this.movesCount--;
61656127 844 }
9aeba28a
BA
845 if (move.subTurn == 1) this.firstMove.pop();
846 this.subTurn = move.subTurn;
847 this.toOldKingPos(move);
61656127 848 }
7b53b5a7 849
9aeba28a 850 toOldKingPos(move) {
7b53b5a7
BA
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
ad1e629e
BA
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);
6980d66b
BA
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 }
ad1e629e
BA
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)];
6980d66b 902 if (!moves[mIdx].next) return moves[mIdx];
ad1e629e
BA
903 const move2 = moves[mIdx].next;
904 delete moves[mIdx]["next"];
905 return [moves[mIdx], move2];
906 }
907
7b53b5a7
BA
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 }
7e8a7ea1 919
0d5335de 920};