Fix Musketeer, Joker, Shinobi. Start draft of Cwda
[vchess.git] / client / src / variants / Eightpieces.js
1 import { randInt } from "@/utils/alea";
2 import { ChessRules, PiPo, Move } from "@/base_rules";
3
4 export class EightpiecesRules extends ChessRules {
5
6 static get JAILER() {
7 return "j";
8 }
9 static get SENTRY() {
10 return "s";
11 }
12 static get LANCER() {
13 return "l";
14 }
15
16 static get IMAGE_EXTENSION() {
17 // Temporarily, for the time SVG pieces are being designed:
18 return ".png";
19 }
20
21 // Lancer directions *from white perspective*
22 static get LANCER_DIRS() {
23 return {
24 'c': [-1, 0], //north
25 'd': [-1, 1], //N-E
26 'e': [0, 1], //east
27 'f': [1, 1], //S-E
28 'g': [1, 0], //south
29 'h': [1, -1], //S-W
30 'm': [0, -1], //west
31 'o': [-1, -1] //N-W
32 };
33 }
34
35 static get PIECES() {
36 return ChessRules.PIECES
37 .concat([V.JAILER, V.SENTRY])
38 .concat(Object.keys(V.LANCER_DIRS));
39 }
40
41 getPiece(i, j) {
42 const piece = this.board[i][j].charAt(1);
43 // Special lancer case: 8 possible orientations
44 if (Object.keys(V.LANCER_DIRS).includes(piece)) return V.LANCER;
45 return piece;
46 }
47
48 getPpath(b, color, score, orientation) {
49 if ([V.JAILER, V.SENTRY].includes(b[1])) return "Eightpieces/tmp_png/" + b;
50 if (Object.keys(V.LANCER_DIRS).includes(b[1])) {
51 if (orientation == 'w') return "Eightpieces/tmp_png/" + b;
52 // Find opposite direction for adequate display:
53 let oppDir = '';
54 switch (b[1]) {
55 case 'c':
56 oppDir = 'g';
57 break;
58 case 'g':
59 oppDir = 'c';
60 break;
61 case 'd':
62 oppDir = 'h';
63 break;
64 case 'h':
65 oppDir = 'd';
66 break;
67 case 'e':
68 oppDir = 'm';
69 break;
70 case 'm':
71 oppDir = 'e';
72 break;
73 case 'f':
74 oppDir = 'o';
75 break;
76 case 'o':
77 oppDir = 'f';
78 break;
79 }
80 return "Eightpieces/tmp_png/" + b[0] + oppDir;
81 }
82 // TODO: after we have SVG pieces, remove the folder and next prefix:
83 return "Eightpieces/tmp_png/" + b;
84 }
85
86 getPPpath(m, orientation) {
87 return (
88 this.getPpath(
89 m.appear[0].c + m.appear[0].p,
90 null,
91 null,
92 orientation
93 )
94 );
95 }
96
97 static ParseFen(fen) {
98 const fenParts = fen.split(" ");
99 return Object.assign(
100 ChessRules.ParseFen(fen),
101 { sentrypush: fenParts[5] }
102 );
103 }
104
105 static IsGoodFen(fen) {
106 if (!ChessRules.IsGoodFen(fen)) return false;
107 const fenParsed = V.ParseFen(fen);
108 // 5) Check sentry push (if any)
109 if (
110 fenParsed.sentrypush != "-" &&
111 !fenParsed.sentrypush.match(/^([a-h][1-8]){2,2}$/)
112 ) {
113 return false;
114 }
115 return true;
116 }
117
118 getFen() {
119 return super.getFen() + " " + this.getSentrypushFen();
120 }
121
122 getFenForRepeat() {
123 return super.getFenForRepeat() + "_" + this.getSentrypushFen();
124 }
125
126 getSentrypushFen() {
127 const L = this.sentryPush.length;
128 if (!this.sentryPush[L-1]) return "-";
129 let res = "";
130 const spL = this.sentryPush[L-1].length;
131 // Condensate path: just need initial and final squares:
132 return [0, spL - 1]
133 .map(i => V.CoordsToSquare(this.sentryPush[L-1][i]))
134 .join("");
135 }
136
137 setOtherVariables(fen) {
138 super.setOtherVariables(fen);
139 // subTurn == 2 only when a sentry moved, and is about to push something
140 this.subTurn = 1;
141 // Sentry position just after a "capture" (subTurn from 1 to 2)
142 this.sentryPos = null;
143 // Stack pieces' forbidden squares after a sentry move at each turn
144 const parsedFen = V.ParseFen(fen);
145 if (parsedFen.sentrypush == "-") this.sentryPush = [null];
146 else {
147 // Expand init + dest squares into a full path:
148 const init = V.SquareToCoords(parsedFen.sentrypush.substr(0, 2)),
149 dest = V.SquareToCoords(parsedFen.sentrypush.substr(2));
150 let newPath = [init];
151 const delta = ['x', 'y'].map(i => Math.abs(dest[i] - init[i]));
152 // Check that it's not a knight movement:
153 if (delta[0] == 0 || delta[1] == 0 || delta[0] == delta[1]) {
154 const step = ['x', 'y'].map((i, idx) => {
155 return (dest[i] - init[i]) / delta[idx] || 0
156 });
157 let x = init.x + step[0],
158 y = init.y + step[1];
159 while (x != dest.x || y != dest.y) {
160 newPath.push({ x: x, y: y });
161 x += step[0];
162 y += step[1];
163 }
164 }
165 newPath.push(dest);
166 this.sentryPush = [newPath];
167 }
168 }
169
170 static GenRandInitFen(randomness) {
171 if (randomness == 0)
172 return "jfsqkbnr/pppppppp/8/8/8/8/PPPPPPPP/JDSQKBNR w 0 ahah - -";
173
174 const baseFen = ChessRules.GenRandInitFen(randomness);
175 const fenParts = baseFen.split(' ');
176 const posParts = fenParts[0].split('/');
177
178 // Replace one bishop by sentry, so that sentries on different colors
179 // Also replace one random rook by jailer,
180 // and one random knight by lancer (facing north/south)
181
182 // "replaced" array contains -2 initially, then either -1 if skipped,
183 // or (eventually) the index of replacement:
184 let newPos = { 0: "", 7: "" };
185 let sentryOddity = -1;
186 for (let rank of [0, 7]) {
187 let replaced = { 'b': -2, 'n': -2, 'r': -2 };
188 for (let i = 0; i < 8; i++) {
189 const curChar = posParts[rank].charAt(i).toLowerCase();
190 if (['b', 'n', 'r'].includes(curChar)) {
191 if (
192 replaced[curChar] == -1 ||
193 (curChar == 'b' && rank == 7 && i % 2 == sentryOddity) ||
194 (
195 (curChar != 'b' || rank == 0) &&
196 replaced[curChar] == -2 &&
197 randInt(2) == 0
198 )
199 ) {
200 replaced[curChar] = i;
201 if (curChar == 'b') {
202 if (sentryOddity < 0) sentryOddity = i % 2;
203 newPos[rank] += 's';
204 }
205 else if (curChar == 'r') newPos[rank] += 'j';
206 else
207 // Lancer: orientation depends on side
208 newPos[rank] += (rank == 0 ? 'g' : 'c');
209 }
210 else {
211 if (replaced[curChar] == -2) replaced[curChar]++;
212 newPos[rank] += curChar;
213 }
214 }
215 else newPos[rank] += curChar;
216 }
217 }
218
219 return (
220 newPos[0] + "/" + posParts.slice(1, 7).join('/') + "/" +
221 newPos[7].toUpperCase() + " " + fenParts.slice(1, 5).join(' ') + " -"
222 );
223 }
224
225 canTake([x1, y1], [x2, y2]) {
226 if (this.subTurn == 2)
227 // Only self captures on this subturn:
228 return this.getColor(x1, y1) == this.getColor(x2, y2);
229 return super.canTake([x1, y1], [x2, y2]);
230 }
231
232 // Is piece on square (x,y) immobilized?
233 isImmobilized([x, y]) {
234 const color = this.getColor(x, y);
235 const oppCol = V.GetOppCol(color);
236 for (let step of V.steps[V.ROOK]) {
237 const [i, j] = [x + step[0], y + step[1]];
238 if (
239 V.OnBoard(i, j) &&
240 this.board[i][j] != V.EMPTY &&
241 this.getColor(i, j) == oppCol
242 ) {
243 if (this.getPiece(i, j) == V.JAILER) return [i, j];
244 }
245 }
246 return null;
247 }
248
249 canIplay(side, [x, y]) {
250 return (
251 (this.subTurn == 1 && this.turn == side && this.getColor(x, y) == side)
252 ||
253 (this.subTurn == 2 && x == this.sentryPos.x && y == this.sentryPos.y)
254 );
255 }
256
257 getPotentialMovesFrom([x, y]) {
258 const piece = this.getPiece(x, y);
259 const L = this.sentryPush.length;
260 // At subTurn == 2, jailers aren't effective (Jeff K)
261 if (this.subTurn == 1) {
262 const jsq = this.isImmobilized([x, y]);
263 if (!!jsq) {
264 let moves = [];
265 // Special pass move if king:
266 if (piece == V.KING) {
267 moves.push(
268 new Move({
269 appear: [],
270 vanish: [],
271 start: { x: x, y: y },
272 end: { x: jsq[0], y: jsq[1] }
273 })
274 );
275 }
276 else if (piece == V.LANCER && !!this.sentryPush[L-1]) {
277 // A pushed lancer next to the jailer: reorient
278 const color = this.getColor(x, y);
279 const curDir = this.board[x][y].charAt(1);
280 Object.keys(V.LANCER_DIRS).forEach(k => {
281 moves.push(
282 new Move({
283 appear: [{ x: x, y: y, c: color, p: k }],
284 vanish: [{ x: x, y: y, c: color, p: curDir }],
285 start: { x: x, y: y },
286 end: { x: jsq[0], y: jsq[1] }
287 })
288 );
289 });
290 }
291 return moves;
292 }
293 }
294 let moves = [];
295 switch (piece) {
296 case V.JAILER:
297 moves = this.getPotentialJailerMoves([x, y]);
298 break;
299 case V.SENTRY:
300 moves = this.getPotentialSentryMoves([x, y]);
301 break;
302 case V.LANCER:
303 moves = this.getPotentialLancerMoves([x, y]);
304 break;
305 default:
306 moves = super.getPotentialMovesFrom([x, y]);
307 break;
308 }
309 if (!!this.sentryPush[L-1]) {
310 // Delete moves walking back on sentry push path,
311 // only if not a pawn, and the piece is the pushed one.
312 const pl = this.sentryPush[L-1].length;
313 const finalPushedSq = this.sentryPush[L-1][pl-1];
314 moves = moves.filter(m => {
315 if (
316 m.vanish[0].p != V.PAWN &&
317 m.start.x == finalPushedSq.x && m.start.y == finalPushedSq.y &&
318 this.sentryPush[L-1].some(sq => sq.x == m.end.x && sq.y == m.end.y)
319 ) {
320 return false;
321 }
322 return true;
323 });
324 }
325 else if (this.subTurn == 2) {
326 // Put back the sentinel on board:
327 const color = this.turn;
328 moves.forEach(m => {
329 m.appear.push({x: x, y: y, p: V.SENTRY, c: color});
330 });
331 }
332 return moves;
333 }
334
335 getPotentialPawnMoves([x, y]) {
336 const color = this.getColor(x, y);
337 let moves = [];
338 const [sizeX, sizeY] = [V.size.x, V.size.y];
339 let shiftX = (color == "w" ? -1 : 1);
340 if (this.subTurn == 2) shiftX *= -1;
341 const firstRank = color == "w" ? sizeX - 1 : 0;
342 const startRank = color == "w" ? sizeX - 2 : 1;
343 const lastRank = color == "w" ? 0 : sizeX - 1;
344
345 // Pawns might be pushed on 1st rank and attempt to move again:
346 if (!V.OnBoard(x + shiftX, y)) return [];
347
348 // A push cannot put a pawn on last rank (it goes backward)
349 let finalPieces = [V.PAWN];
350 if (x + shiftX == lastRank) {
351 // Only allow direction facing inside board:
352 const allowedLancerDirs =
353 lastRank == 0
354 ? ['e', 'f', 'g', 'h', 'm']
355 : ['c', 'd', 'e', 'm', 'o'];
356 finalPieces =
357 allowedLancerDirs
358 .concat([V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN, V.SENTRY, V.JAILER]);
359 }
360 if (this.board[x + shiftX][y] == V.EMPTY) {
361 // One square forward
362 for (let piece of finalPieces) {
363 moves.push(
364 this.getBasicMove([x, y], [x + shiftX, y], {
365 c: color,
366 p: piece
367 })
368 );
369 }
370 if (
371 // 2-squares jumps forbidden if pawn push
372 this.subTurn == 1 &&
373 [startRank, firstRank].includes(x) &&
374 this.board[x + 2 * shiftX][y] == V.EMPTY
375 ) {
376 // Two squares jump
377 moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
378 }
379 }
380 // Captures
381 for (let shiftY of [-1, 1]) {
382 if (
383 y + shiftY >= 0 &&
384 y + shiftY < sizeY &&
385 this.board[x + shiftX][y + shiftY] != V.EMPTY &&
386 this.canTake([x, y], [x + shiftX, y + shiftY])
387 ) {
388 for (let piece of finalPieces) {
389 moves.push(
390 this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
391 c: color,
392 p: piece
393 })
394 );
395 }
396 }
397 }
398
399 // En passant: only on subTurn == 1
400 const Lep = this.epSquares.length;
401 const epSquare = this.epSquares[Lep - 1];
402 if (
403 this.subTurn == 1 &&
404 !!epSquare &&
405 epSquare.x == x + shiftX &&
406 Math.abs(epSquare.y - y) == 1
407 ) {
408 let enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]);
409 enpassantMove.vanish.push({
410 x: x,
411 y: epSquare.y,
412 p: "p",
413 c: this.getColor(x, epSquare.y)
414 });
415 moves.push(enpassantMove);
416 }
417
418 return moves;
419 }
420
421 doClick(square) {
422 if (isNaN(square[0])) return null;
423 const L = this.sentryPush.length;
424 const [x, y] = [square[0], square[1]];
425 const color = this.turn;
426 if (
427 this.subTurn == 2 ||
428 this.board[x][y] == V.EMPTY ||
429 this.getPiece(x, y) != V.LANCER ||
430 this.getColor(x, y) != color ||
431 !!this.sentryPush[L-1]
432 ) {
433 return null;
434 }
435 // Stuck lancer?
436 const orientation = this.board[x][y][1];
437 const step = V.LANCER_DIRS[orientation];
438 if (!V.OnBoard(x + step[0], y + step[1])) {
439 let choices = [];
440 Object.keys(V.LANCER_DIRS).forEach(k => {
441 const dir = V.LANCER_DIRS[k];
442 if (
443 (dir[0] != step[0] || dir[1] != step[1]) &&
444 V.OnBoard(x + dir[0], y + dir[1])
445 ) {
446 choices.push(
447 new Move({
448 vanish: [
449 new PiPo({
450 x: x,
451 y: y,
452 c: color,
453 p: orientation
454 })
455 ],
456 appear: [
457 new PiPo({
458 x: x,
459 y: y,
460 c: color,
461 p: k
462 })
463 ],
464 start: { x: x, y : y },
465 end: { x: -1, y: -1 }
466 })
467 );
468 }
469 });
470 return choices;
471 }
472 return null;
473 }
474
475 // Obtain all lancer moves in "step" direction
476 getPotentialLancerMoves_aux([x, y], step, tr) {
477 let moves = [];
478 // Add all moves to vacant squares until opponent is met:
479 const color = this.getColor(x, y);
480 const oppCol =
481 this.subTurn == 1
482 ? V.GetOppCol(color)
483 // at subTurn == 2, consider own pieces as opponent
484 : color;
485 let sq = [x + step[0], y + step[1]];
486 while (V.OnBoard(sq[0], sq[1]) && this.getColor(sq[0], sq[1]) != oppCol) {
487 if (this.board[sq[0]][sq[1]] == V.EMPTY)
488 moves.push(this.getBasicMove([x, y], sq, tr));
489 sq[0] += step[0];
490 sq[1] += step[1];
491 }
492 if (V.OnBoard(sq[0], sq[1]))
493 // Add capturing move
494 moves.push(this.getBasicMove([x, y], sq, tr));
495 return moves;
496 }
497
498 getPotentialLancerMoves([x, y]) {
499 let moves = [];
500 // Add all lancer possible orientations, similar to pawn promotions.
501 // Except if just after a push: allow all movements from init square then
502 const L = this.sentryPush.length;
503 const color = this.getColor(x, y);
504 const dirCode = this.board[x][y][1];
505 const curDir = V.LANCER_DIRS[dirCode];
506 if (!!this.sentryPush[L-1]) {
507 // Maybe I was pushed
508 const pl = this.sentryPush[L-1].length;
509 if (
510 this.sentryPush[L-1][pl-1].x == x &&
511 this.sentryPush[L-1][pl-1].y == y
512 ) {
513 // I was pushed: allow all directions (for this move only), but
514 // do not change direction after moving, *except* if I keep the
515 // same orientation in which I was pushed.
516 // Also allow simple reorientation ("capturing king"):
517 if (!V.OnBoard(x + curDir[0], y + curDir[1])) {
518 const kp = this.kingPos[color];
519 let reorientMoves = [];
520 Object.keys(V.LANCER_DIRS).forEach(k => {
521 const dir = V.LANCER_DIRS[k];
522 if (
523 (dir[0] != curDir[0] || dir[1] != curDir[1]) &&
524 V.OnBoard(x + dir[0], y + dir[1])
525 ) {
526 reorientMoves.push(
527 new Move({
528 vanish: [
529 new PiPo({
530 x: x,
531 y: y,
532 c: color,
533 p: dirCode
534 })
535 ],
536 appear: [
537 new PiPo({
538 x: x,
539 y: y,
540 c: color,
541 p: k
542 })
543 ],
544 start: { x: x, y : y },
545 end: { x: kp[0], y: kp[1] }
546 })
547 );
548 }
549 });
550 Array.prototype.push.apply(moves, reorientMoves);
551 }
552 Object.values(V.LANCER_DIRS).forEach(step => {
553 const dirCode = Object.keys(V.LANCER_DIRS).find(k => {
554 return (
555 V.LANCER_DIRS[k][0] == step[0] &&
556 V.LANCER_DIRS[k][1] == step[1]
557 );
558 });
559 const dirMoves =
560 this.getPotentialLancerMoves_aux(
561 [x, y],
562 step,
563 { p: dirCode, c: color }
564 );
565 if (curDir[0] == step[0] && curDir[1] == step[1]) {
566 // Keeping same orientation: can choose after
567 let chooseMoves = [];
568 dirMoves.forEach(m => {
569 Object.keys(V.LANCER_DIRS).forEach(k => {
570 const newDir = V.LANCER_DIRS[k];
571 // Prevent orientations toward outer board:
572 if (V.OnBoard(m.end.x + newDir[0], m.end.y + newDir[1])) {
573 let mk = JSON.parse(JSON.stringify(m));
574 mk.appear[0].p = k;
575 chooseMoves.push(mk);
576 }
577 });
578 });
579 Array.prototype.push.apply(moves, chooseMoves);
580 }
581 else Array.prototype.push.apply(moves, dirMoves);
582 });
583 return moves;
584 }
585 }
586 // I wasn't pushed: standard lancer move
587 const monodirMoves =
588 this.getPotentialLancerMoves_aux([x, y], V.LANCER_DIRS[dirCode]);
589 // Add all possible orientations aftermove except if I'm being pushed
590 if (this.subTurn == 1) {
591 monodirMoves.forEach(m => {
592 Object.keys(V.LANCER_DIRS).forEach(k => {
593 const newDir = V.LANCER_DIRS[k];
594 // Prevent orientations toward outer board:
595 if (V.OnBoard(m.end.x + newDir[0], m.end.y + newDir[1])) {
596 let mk = JSON.parse(JSON.stringify(m));
597 mk.appear[0].p = k;
598 moves.push(mk);
599 }
600 });
601 });
602 return moves;
603 }
604 else {
605 // I'm pushed: add potential nudges, except for current orientation
606 let potentialNudges = [];
607 for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
608 if (
609 (step[0] != curDir[0] || step[1] != curDir[1]) &&
610 V.OnBoard(x + step[0], y + step[1]) &&
611 this.board[x + step[0]][y + step[1]] == V.EMPTY
612 ) {
613 const newDirCode = Object.keys(V.LANCER_DIRS).find(k => {
614 const codeStep = V.LANCER_DIRS[k];
615 return (codeStep[0] == step[0] && codeStep[1] == step[1]);
616 });
617 potentialNudges.push(
618 this.getBasicMove(
619 [x, y],
620 [x + step[0], y + step[1]],
621 { c: color, p: newDirCode }
622 )
623 );
624 }
625 }
626 return monodirMoves.concat(potentialNudges);
627 }
628 }
629
630 getPotentialSentryMoves([x, y]) {
631 // The sentry moves a priori like a bishop:
632 let moves = super.getPotentialBishopMoves([x, y]);
633 // ...but captures are replaced by special move, if and only if
634 // "captured" piece can move now, considered as the capturer unit.
635 // --> except is subTurn == 2, in this case I don't push anything.
636 if (this.subTurn == 2) return moves.filter(m => m.vanish.length == 1);
637 moves.forEach(m => {
638 if (m.vanish.length == 2) {
639 // Temporarily cancel the sentry capture:
640 m.appear.pop();
641 m.vanish.pop();
642 }
643 });
644 const color = this.getColor(x, y);
645 const fMoves = moves.filter(m => {
646 // Can the pushed unit make any move? ...resulting in a non-self-check?
647 if (m.appear.length == 0) {
648 let res = false;
649 this.play(m);
650 let moves2 = this.getPotentialMovesFrom([m.end.x, m.end.y]);
651 for (let m2 of moves2) {
652 this.play(m2);
653 res = !this.underCheck(color);
654 this.undo(m2);
655 if (res) break;
656 }
657 this.undo(m);
658 return res;
659 }
660 return true;
661 });
662 return fMoves;
663 }
664
665 getPotentialJailerMoves([x, y]) {
666 return super.getPotentialRookMoves([x, y]).filter(m => {
667 // Remove jailer captures
668 return m.vanish[0].p != V.JAILER || m.vanish.length == 1;
669 });
670 }
671
672 getPotentialKingMoves(sq) {
673 const moves = this.getSlideNJumpMoves(
674 sq,
675 V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
676 "oneStep"
677 );
678 return (
679 this.subTurn == 1
680 ? moves.concat(this.getCastleMoves(sq))
681 : moves
682 );
683 }
684
685 atLeastOneMove() {
686 // If in second-half of a move, we already know that a move is possible
687 if (this.subTurn == 2) return true;
688 return super.atLeastOneMove();
689 }
690
691 filterValid(moves) {
692 if (moves.length == 0) return [];
693 const basicFilter = (m, c) => {
694 this.play(m);
695 const res = !this.underCheck(c);
696 this.undo(m);
697 return res;
698 };
699 // Disable check tests for sentry pushes,
700 // because in this case the move isn't finished
701 let movesWithoutSentryPushes = [];
702 let movesWithSentryPushes = [];
703 moves.forEach(m => {
704 // Second condition below for special king "pass" moves
705 if (m.appear.length > 0 || m.vanish.length == 0)
706 movesWithoutSentryPushes.push(m);
707 else movesWithSentryPushes.push(m);
708 });
709 const color = this.turn;
710 const oppCol = V.GetOppCol(color);
711 const filteredMoves =
712 movesWithoutSentryPushes.filter(m => basicFilter(m, color));
713 // If at least one full move made, everything is allowed.
714 // Else: forbid checks and captures.
715 return (
716 this.movesCount >= 2
717 ? filteredMoves
718 : filteredMoves.filter(m => {
719 return (m.vanish.length <= 1 && basicFilter(m, oppCol));
720 })
721 ).concat(movesWithSentryPushes);
722 }
723
724 getAllValidMoves() {
725 if (this.subTurn == 1) return super.getAllValidMoves();
726 // Sentry push:
727 const sentrySq = [this.sentryPos.x, this.sentryPos.y];
728 return this.filterValid(this.getPotentialMovesFrom(sentrySq));
729 }
730
731 isAttacked(sq, color) {
732 return (
733 super.isAttacked(sq, color) ||
734 this.isAttackedByLancer(sq, color) ||
735 this.isAttackedBySentry(sq, color)
736 // The jailer doesn't capture.
737 );
738 }
739
740 isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) {
741 for (let step of steps) {
742 let rx = x + step[0],
743 ry = y + step[1];
744 while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) {
745 rx += step[0];
746 ry += step[1];
747 }
748 if (
749 V.OnBoard(rx, ry) &&
750 this.getPiece(rx, ry) == piece &&
751 this.getColor(rx, ry) == color &&
752 !this.isImmobilized([rx, ry])
753 ) {
754 return true;
755 }
756 }
757 return false;
758 }
759
760 isAttackedByPawn([x, y], color) {
761 const pawnShift = (color == "w" ? 1 : -1);
762 if (x + pawnShift >= 0 && x + pawnShift < V.size.x) {
763 for (let i of [-1, 1]) {
764 if (
765 y + i >= 0 &&
766 y + i < V.size.y &&
767 this.getPiece(x + pawnShift, y + i) == V.PAWN &&
768 this.getColor(x + pawnShift, y + i) == color &&
769 !this.isImmobilized([x + pawnShift, y + i])
770 ) {
771 return true;
772 }
773 }
774 }
775 return false;
776 }
777
778 isAttackedByLancer([x, y], color) {
779 for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
780 // If in this direction there are only enemy pieces and empty squares,
781 // and we meet a lancer: can he reach us?
782 // NOTE: do not stop at first lancer, there might be several!
783 let coord = { x: x + step[0], y: y + step[1] };
784 let lancerPos = [];
785 while (
786 V.OnBoard(coord.x, coord.y) &&
787 (
788 this.board[coord.x][coord.y] == V.EMPTY ||
789 this.getColor(coord.x, coord.y) == color
790 )
791 ) {
792 if (
793 this.getPiece(coord.x, coord.y) == V.LANCER &&
794 !this.isImmobilized([coord.x, coord.y])
795 ) {
796 lancerPos.push({x: coord.x, y: coord.y});
797 }
798 coord.x += step[0];
799 coord.y += step[1];
800 }
801 const L = this.sentryPush.length;
802 const pl = (!!this.sentryPush[L-1] ? this.sentryPush[L-1].length : 0);
803 for (let xy of lancerPos) {
804 const dir = V.LANCER_DIRS[this.board[xy.x][xy.y].charAt(1)];
805 if (
806 (dir[0] == -step[0] && dir[1] == -step[1]) ||
807 // If the lancer was just pushed, this is an attack too:
808 (
809 !!this.sentryPush[L-1] &&
810 this.sentryPush[L-1][pl-1].x == xy.x &&
811 this.sentryPush[L-1][pl-1].y == xy.y
812 )
813 ) {
814 return true;
815 }
816 }
817 }
818 return false;
819 }
820
821 // Helper to check sentries attacks:
822 selfAttack([x1, y1], [x2, y2]) {
823 const color = this.getColor(x1, y1);
824 const oppCol = V.GetOppCol(color);
825 const sliderAttack = (allowedSteps, lancer) => {
826 const deltaX = x2 - x1,
827 absDeltaX = Math.abs(deltaX);
828 const deltaY = y2 - y1,
829 absDeltaY = Math.abs(deltaY);
830 const step = [ deltaX / absDeltaX || 0, deltaY / absDeltaY || 0 ];
831 if (
832 // Check that the step is a priori valid:
833 (absDeltaX != absDeltaY && deltaX != 0 && deltaY != 0) ||
834 allowedSteps.every(st => st[0] != step[0] || st[1] != step[1])
835 ) {
836 return false;
837 }
838 let sq = [ x1 + step[0], y1 + step[1] ];
839 while (sq[0] != x2 || sq[1] != y2) {
840 if (
841 // NOTE: no need to check OnBoard in this special case
842 (!lancer && this.board[sq[0]][sq[1]] != V.EMPTY) ||
843 (!!lancer && this.getColor(sq[0], sq[1]) == oppCol)
844 ) {
845 return false;
846 }
847 sq[0] += step[0];
848 sq[1] += step[1];
849 }
850 return true;
851 };
852 switch (this.getPiece(x1, y1)) {
853 case V.PAWN: {
854 // Pushed pawns move as enemy pawns
855 const shift = (color == 'w' ? 1 : -1);
856 return (x1 + shift == x2 && Math.abs(y1 - y2) == 1);
857 }
858 case V.KNIGHT: {
859 const deltaX = Math.abs(x1 - x2);
860 const deltaY = Math.abs(y1 - y2);
861 return (
862 deltaX + deltaY == 3 &&
863 [1, 2].includes(deltaX) &&
864 [1, 2].includes(deltaY)
865 );
866 }
867 case V.ROOK:
868 return sliderAttack(V.steps[V.ROOK]);
869 case V.BISHOP:
870 return sliderAttack(V.steps[V.BISHOP]);
871 case V.QUEEN:
872 return sliderAttack(V.steps[V.ROOK].concat(V.steps[V.BISHOP]));
873 case V.LANCER: {
874 // Special case: as long as no enemy units stands in-between,
875 // it attacks (if it points toward the king).
876 const allowedStep = V.LANCER_DIRS[this.board[x1][y1].charAt(1)];
877 return sliderAttack([allowedStep], "lancer");
878 }
879 // No sentries or jailer tests: they cannot self-capture
880 }
881 return false;
882 }
883
884 isAttackedBySentry([x, y], color) {
885 // Attacked by sentry means it can self-take our king.
886 // Just check diagonals of enemy sentry(ies), and if it reaches
887 // one of our pieces: can I self-take?
888 const myColor = V.GetOppCol(color);
889 let candidates = [];
890 for (let i=0; i<V.size.x; i++) {
891 for (let j=0; j<V.size.y; j++) {
892 if (
893 this.getPiece(i,j) == V.SENTRY &&
894 this.getColor(i,j) == color &&
895 !this.isImmobilized([i, j])
896 ) {
897 for (let step of V.steps[V.BISHOP]) {
898 let sq = [ i + step[0], j + step[1] ];
899 while (
900 V.OnBoard(sq[0], sq[1]) &&
901 this.board[sq[0]][sq[1]] == V.EMPTY
902 ) {
903 sq[0] += step[0];
904 sq[1] += step[1];
905 }
906 if (
907 V.OnBoard(sq[0], sq[1]) &&
908 this.getColor(sq[0], sq[1]) == myColor
909 ) {
910 candidates.push([ sq[0], sq[1] ]);
911 }
912 }
913 }
914 }
915 }
916 for (let c of candidates)
917 if (this.selfAttack(c, [x, y])) return true;
918 return false;
919 }
920
921 // Jailer doesn't capture or give check
922
923 prePlay(move) {
924 if (move.appear.length == 0 && move.vanish.length == 1)
925 // The sentry is about to push a piece: subTurn goes from 1 to 2
926 this.sentryPos = { x: move.end.x, y: move.end.y };
927 if (this.subTurn == 2 && move.vanish[0].p != V.PAWN) {
928 // A piece is pushed: forbid array of squares between start and end
929 // of move, included (except if it's a pawn)
930 let squares = [];
931 if ([V.KNIGHT,V.KING].includes(move.vanish[0].p))
932 // short-range pieces: just forbid initial square
933 squares.push({ x: move.start.x, y: move.start.y });
934 else {
935 const deltaX = move.end.x - move.start.x;
936 const deltaY = move.end.y - move.start.y;
937 const step = [
938 deltaX / Math.abs(deltaX) || 0,
939 deltaY / Math.abs(deltaY) || 0
940 ];
941 for (
942 let sq = {x: move.start.x, y: move.start.y};
943 sq.x != move.end.x || sq.y != move.end.y;
944 sq.x += step[0], sq.y += step[1]
945 ) {
946 squares.push({ x: sq.x, y: sq.y });
947 }
948 }
949 // Add end square as well, to know if I was pushed (useful for lancers)
950 squares.push({ x: move.end.x, y: move.end.y });
951 this.sentryPush.push(squares);
952 } else this.sentryPush.push(null);
953 }
954
955 play(move) {
956 this.prePlay(move);
957 move.flags = JSON.stringify(this.aggregateFlags());
958 this.epSquares.push(this.getEpSquare(move));
959 V.PlayOnBoard(this.board, move);
960 // Is it a sentry push? (useful for undo)
961 move.sentryPush = (this.subTurn == 2);
962 if (this.subTurn == 1) this.movesCount++;
963 if (move.appear.length == 0 && move.vanish.length == 1) this.subTurn = 2;
964 else {
965 // Turn changes only if not a sentry "pre-push"
966 this.turn = V.GetOppCol(this.turn);
967 this.subTurn = 1;
968 }
969 this.postPlay(move);
970 }
971
972 postPlay(move) {
973 if (move.vanish.length == 0 || this.subTurn == 2)
974 // Special pass move of the king, or sentry pre-push: nothing to update
975 return;
976 const c = move.vanish[0].c;
977 const piece = move.vanish[0].p;
978 const firstRank = c == "w" ? V.size.x - 1 : 0;
979
980 if (piece == V.KING) {
981 this.kingPos[c][0] = move.appear[0].x;
982 this.kingPos[c][1] = move.appear[0].y;
983 this.castleFlags[c] = [V.size.y, V.size.y];
984 return;
985 }
986 // Update castling flags if rooks are moved
987 const oppCol = V.GetOppCol(c);
988 const oppFirstRank = V.size.x - 1 - firstRank;
989 if (
990 move.start.x == firstRank && //our rook moves?
991 this.castleFlags[c].includes(move.start.y)
992 ) {
993 const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
994 this.castleFlags[c][flagIdx] = V.size.y;
995 } else if (
996 move.end.x == oppFirstRank && //we took opponent rook?
997 this.castleFlags[oppCol].includes(move.end.y)
998 ) {
999 const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1);
1000 this.castleFlags[oppCol][flagIdx] = V.size.y;
1001 }
1002 }
1003
1004 undo(move) {
1005 this.epSquares.pop();
1006 this.disaggregateFlags(JSON.parse(move.flags));
1007 V.UndoOnBoard(this.board, move);
1008 // Decrement movesCount except if the move is a sentry push
1009 if (!move.sentryPush) this.movesCount--;
1010 if (this.subTurn == 2) this.subTurn = 1;
1011 else {
1012 this.turn = V.GetOppCol(this.turn);
1013 if (move.sentryPush) this.subTurn = 2;
1014 }
1015 this.postUndo(move);
1016 }
1017
1018 postUndo(move) {
1019 super.postUndo(move);
1020 this.sentryPush.pop();
1021 }
1022
1023 static get VALUES() {
1024 return Object.assign(
1025 { l: 4.8, s: 2.8, j: 3.8 }, //Jeff K. estimations
1026 ChessRules.VALUES
1027 );
1028 }
1029
1030 getComputerMove() {
1031 const maxeval = V.INFINITY;
1032 const color = this.turn;
1033 let moves1 = this.getAllValidMoves();
1034
1035 if (moves1.length == 0)
1036 // TODO: this situation should not happen
1037 return null;
1038
1039 const setEval = (move, next) => {
1040 const score = this.getCurrentScore();
1041 const curEval = move.eval;
1042 if (score != "*") {
1043 move.eval =
1044 score == "1/2"
1045 ? 0
1046 : (score == "1-0" ? 1 : -1) * maxeval;
1047 } else move.eval = this.evalPosition();
1048 if (
1049 // "next" is defined after sentry pushes
1050 !!next && (
1051 !curEval ||
1052 color == 'w' && move.eval > curEval ||
1053 color == 'b' && move.eval < curEval
1054 )
1055 ) {
1056 move.second = next;
1057 }
1058 };
1059
1060 // Just search_depth == 1 (because of sentries. TODO: can do better...)
1061 moves1.forEach(m1 => {
1062 this.play(m1);
1063 if (this.subTurn == 1) setEval(m1);
1064 else {
1065 // Need to play every pushes and count:
1066 const moves2 = this.getAllValidMoves();
1067 moves2.forEach(m2 => {
1068 this.play(m2);
1069 setEval(m1, m2);
1070 this.undo(m2);
1071 });
1072 }
1073 this.undo(m1);
1074 });
1075
1076 moves1.sort((a, b) => {
1077 return (color == "w" ? 1 : -1) * (b.eval - a.eval);
1078 });
1079 let candidates = [0];
1080 for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++)
1081 candidates.push(j);
1082 const choice = moves1[candidates[randInt(candidates.length)]];
1083 return (!choice.second ? choice : [choice, choice.second]);
1084 }
1085
1086 // For moves notation:
1087 static get LANCER_DIRNAMES() {
1088 return {
1089 'c': "N",
1090 'd': "NE",
1091 'e': "E",
1092 'f': "SE",
1093 'g': "S",
1094 'h': "SW",
1095 'm': "W",
1096 'o': "NW"
1097 };
1098 }
1099
1100 getNotation(move) {
1101 // Special case "king takes jailer" is a pass move
1102 if (move.appear.length == 0 && move.vanish.length == 0) return "pass";
1103 let notation = undefined;
1104 if (this.subTurn == 2) {
1105 // Do not consider appear[1] (sentry) for sentry pushes
1106 const simpleMove = {
1107 appear: [move.appear[0]],
1108 vanish: move.vanish,
1109 start: move.start,
1110 end: move.end
1111 };
1112 notation = super.getNotation(simpleMove);
1113 }
1114 else if (
1115 move.appear.length > 0 &&
1116 move.vanish[0].x == move.appear[0].x &&
1117 move.vanish[0].y == move.appear[0].y
1118 ) {
1119 // Lancer in-place reorientation:
1120 notation = "L" + V.CoordsToSquare(move.start) + ":R";
1121 }
1122 else notation = super.getNotation(move);
1123 if (Object.keys(V.LANCER_DIRNAMES).includes(move.vanish[0].p))
1124 // Lancer: add direction info
1125 notation += "=" + V.LANCER_DIRNAMES[move.appear[0].p];
1126 else if (
1127 move.vanish[0].p == V.PAWN &&
1128 Object.keys(V.LANCER_DIRNAMES).includes(move.appear[0].p)
1129 ) {
1130 // Fix promotions in lancer:
1131 notation = notation.slice(0, -1) +
1132 "L:" + V.LANCER_DIRNAMES[move.appear[0].p];
1133 }
1134 return notation;
1135 }
1136
1137 };