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