Pandemonium 1 & 2, Stealthbomb 1 & 2
[vchess.git] / client / src / variants / Janggi.js
1 import { ChessRules, Move, PiPo } from "@/base_rules";
2 import { randInt } from "@/utils/alea";
3
4 export class JanggiRules extends ChessRules {
5
6 static get Monochrome() {
7 return true;
8 }
9
10 static get Notoodark() {
11 return true;
12 }
13
14 static get Lines() {
15 let lines = [];
16 // Draw all inter-squares lines, shifted:
17 for (let i = 0; i < V.size.x; i++)
18 lines.push([[i+0.5, 0.5], [i+0.5, V.size.y-0.5]]);
19 for (let j = 0; j < V.size.y; j++)
20 lines.push([[0.5, j+0.5], [V.size.x-0.5, j+0.5]]);
21 // Add palaces:
22 lines.push([[0.5, 3.5], [2.5, 5.5]]);
23 lines.push([[0.5, 5.5], [2.5, 3.5]]);
24 lines.push([[9.5, 3.5], [7.5, 5.5]]);
25 lines.push([[9.5, 5.5], [7.5, 3.5]]);
26 return lines;
27 }
28
29 // No castle, but flag: bikjang
30 static get HasCastle() {
31 return false;
32 }
33
34 static get HasEnpassant() {
35 return false;
36 }
37
38 static get ELEPHANT() {
39 return "e";
40 }
41
42 static get CANNON() {
43 return "c";
44 }
45
46 static get ADVISOR() {
47 return "a";
48 }
49
50 static get PIECES() {
51 return [V.PAWN, V.ROOK, V.KNIGHT, V.ELEPHANT, V.ADVISOR, V.KING, V.CANNON];
52 }
53
54 getPpath(b) {
55 return "Janggi/" + b;
56 }
57
58 static get size() {
59 return { x: 10, y: 9};
60 }
61
62 static IsGoodFlags(flags) {
63 // bikjang status of last move + pass
64 return !!flags.match(/^[0-2]{2,2}$/);
65 }
66
67 aggregateFlags() {
68 return [this.bikjangFlag, this.passFlag];
69 }
70
71 disaggregateFlags(flags) {
72 this.bikjangFlag = flags[0];
73 this.passFlag = flags[1];
74 }
75
76 getFlagsFen() {
77 return this.bikjangFlag.toString() + this.passFlag.toString()
78 }
79
80 setFlags(fenflags) {
81 this.bikjangFlag = parseInt(fenflags.charAt(0), 10);
82 this.passFlag = parseInt(fenflags.charAt(1), 10);
83 }
84
85 setOtherVariables(fen) {
86 super.setOtherVariables(fen);
87 // Sub-turn is useful only at first move...
88 this.subTurn = 1;
89 }
90
91 getPotentialMovesFrom([x, y]) {
92 let moves = [];
93 const c = this.getColor(x, y);
94 const oppCol = V.GetOppCol(c);
95 if (this.kingPos[c][0] == x && this.kingPos[c][1] == y) {
96 // Add pass move (might be impossible if undercheck)
97 moves.push(
98 new Move({
99 appear: [],
100 vanish: [],
101 start: { x: this.kingPos[c][0], y: this.kingPos[c][1] },
102 end: { x: this.kingPos[oppCol][0], y: this.kingPos[oppCol][1] }
103 })
104 );
105 }
106 // TODO: next "if" is mutually exclusive with the block above
107 if (this.movesCount <= 1) {
108 const firstRank = (this.movesCount == 0 ? 9 : 0);
109 const initDestFile = new Map([[1, 2], [7, 6]]);
110 // Only option is knight --> elephant swap:
111 if (
112 x == firstRank &&
113 !!initDestFile.get(y) &&
114 this.getPiece(x, y) == V.KNIGHT
115 ) {
116 const destFile = initDestFile.get(y);
117 moves.push(
118 new Move({
119 appear: [
120 new PiPo({
121 x: x,
122 y: destFile,
123 c: c,
124 p: V.KNIGHT
125 }),
126 new PiPo({
127 x: x,
128 y: y,
129 c: c,
130 p: V.ELEPHANT
131 })
132 ],
133 vanish: [
134 new PiPo({
135 x: x,
136 y: y,
137 c: c,
138 p: V.KNIGHT
139 }),
140 new PiPo({
141 x: x,
142 y: destFile,
143 c: c,
144 p: V.ELEPHANT
145 })
146 ],
147 start: { x: x, y: y },
148 end: { x: x, y: destFile }
149 })
150 );
151 }
152 }
153 else {
154 let normalMoves = [];
155 switch (this.getPiece(x, y)) {
156 case V.PAWN:
157 normalMoves = this.getPotentialPawnMoves([x, y]);
158 break;
159 case V.ROOK:
160 normalMoves = this.getPotentialRookMoves([x, y]);
161 break;
162 case V.KNIGHT:
163 normalMoves = this.getPotentialKnightMoves([x, y]);
164 break;
165 case V.ELEPHANT:
166 normalMoves = this.getPotentialElephantMoves([x, y]);
167 break;
168 case V.ADVISOR:
169 normalMoves = this.getPotentialAdvisorMoves([x, y]);
170 break;
171 case V.KING:
172 normalMoves = this.getPotentialKingMoves([x, y]);
173 break;
174 case V.CANNON:
175 normalMoves = this.getPotentialCannonMoves([x, y]);
176 break;
177 }
178 Array.prototype.push.apply(moves, normalMoves);
179 }
180 return moves;
181 }
182
183 getPotentialPawnMoves([x, y]) {
184 const c = this.getColor(x, y);
185 const oppCol = V.GetOppCol(c);
186 const shiftX = (c == 'w' ? -1 : 1);
187 const rank23 = (oppCol == 'w' ? [8, 7] : [1, 2]);
188 let steps = [[shiftX, 0], [0, -1], [0, 1]];
189 // Diagonal moves inside enemy palace:
190 if (y == 4 && x == rank23[0])
191 Array.prototype.push.apply(steps, [[shiftX, 1], [shiftX, -1]]);
192 else if (x == rank23[1]) {
193 if (y == 3) steps.push([shiftX, 1]);
194 else if (y == 5) steps.push([shiftX, -1]);
195 }
196 return super.getSlideNJumpMoves([x, y], steps, "oneStep");
197 }
198
199 knightStepsFromRookStep(step) {
200 if (step[0] == 0) return [ [1, 2*step[1]], [-1, 2*step[1]] ];
201 return [ [2*step[0], 1], [2*step[0], -1] ];
202 }
203
204 getPotentialKnightMoves([x, y]) {
205 let steps = [];
206 for (let rookStep of ChessRules.steps[V.ROOK]) {
207 const [i, j] = [x + rookStep[0], y + rookStep[1]];
208 if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
209 Array.prototype.push.apply(steps,
210 // These moves might be impossible, but need to be checked:
211 this.knightStepsFromRookStep(rookStep));
212 }
213 }
214 return super.getSlideNJumpMoves([x, y], steps, "oneStep");
215 }
216
217 elephantStepsFromRookStep(step) {
218 if (step[0] == 0) return [ [2, 3*step[1]], [-2, 3*step[1]] ];
219 return [ [3*step[0], 2], [3*step[0], -2] ];
220 }
221
222 getPotentialElephantMoves([x, y]) {
223 let steps = [];
224 for (let rookStep of ChessRules.steps[V.ROOK]) {
225 const eSteps = this.elephantStepsFromRookStep(rookStep);
226 const [i, j] = [x + rookStep[0], y + rookStep[1]];
227 if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
228 // Check second crossing:
229 const knightSteps = this.knightStepsFromRookStep(rookStep);
230 for (let k of [0, 1]) {
231 const [ii, jj] = [x + knightSteps[k][0], y + knightSteps[k][1]];
232 if (V.OnBoard(ii, jj) && this.board[ii][jj] == V.EMPTY)
233 steps.push(eSteps[k]); //ok: same ordering
234 }
235 }
236 }
237 return super.getSlideNJumpMoves([x, y], steps, "oneStep");
238 }
239
240 palacePeopleMoves([x, y]) {
241 const c = this.getColor(x, y);
242 let steps = [];
243 // Orthogonal steps:
244 if (x < (c == 'w' ? 9 : 2)) steps.push([1, 0]);
245 if (x > (c == 'w' ? 7 : 0)) steps.push([-1, 0]);
246 if (y > 3) steps.push([0, -1]);
247 if (y < 5) steps.push([0, 1]);
248 // Diagonal steps, if in the middle or corner:
249 if (
250 y != 4 &&
251 (
252 (c == 'w' && x != 8) ||
253 (c == 'b' && x != 1)
254 )
255 ) {
256 // In a corner: maximum one diagonal step available
257 let step = null;
258 const direction = (c == 'w' ? -1 : 1);
259 if ((c == 'w' && x == 9) || (c == 'b' && x == 0)) {
260 // On first line
261 if (y == 3) step = [direction, 1];
262 else step = [direction, -1];
263 }
264 else if ((c == 'w' && x == 7) || (c == 'b' && x == 2)) {
265 // On third line
266 if (y == 3) step = [-direction, 1];
267 else step = [-direction, -1];
268 }
269 steps.push(step);
270 }
271 else if (
272 y == 4 &&
273 (
274 (c == 'w' && x == 8) ||
275 (c == 'b' && x == 1)
276 )
277 ) {
278 // At the middle: all directions available
279 Array.prototype.push.apply(steps, ChessRules.steps[V.BISHOP]);
280 }
281 return super.getSlideNJumpMoves([x, y], steps, "oneStep");
282 }
283
284 getPotentialAdvisorMoves(sq) {
285 return this.palacePeopleMoves(sq);
286 }
287
288 getPotentialKingMoves(sq) {
289 return this.palacePeopleMoves(sq);
290 }
291
292 getPotentialRookMoves([x, y]) {
293 let moves = super.getPotentialRookMoves([x, y]);
294 if ([3, 5].includes(y) && [0, 2, 7, 9].includes(x)) {
295 // In a corner of a palace: move along diagonal
296 const step = [[0, 7].includes(x) ? 1 : -1, 4 - y];
297 const oppCol = V.GetOppCol(this.getColor(x, y));
298 for (let i of [1, 2]) {
299 const [xx, yy] = [x + i * step[0], y + i * step[1]];
300 if (this.board[xx][yy] == V.EMPTY)
301 moves.push(this.getBasicMove([x, y], [xx, yy]));
302 else {
303 if (this.getColor(xx, yy) == oppCol)
304 moves.push(this.getBasicMove([x, y], [xx, yy]));
305 break;
306 }
307 }
308 }
309 else if (y == 4 && [1, 8].includes(x)) {
310 // In the middle of a palace: 4 one-diagonal-step to check
311 Array.prototype.push.apply(
312 moves,
313 super.getSlideNJumpMoves([x, y],
314 ChessRules.steps[V.BISHOP],
315 "oneStep")
316 );
317 }
318 return moves;
319 }
320
321 // NOTE: (mostly) duplicated from Shako (TODO?)
322 getPotentialCannonMoves([x, y]) {
323 const oppCol = V.GetOppCol(this.turn);
324 let moves = [];
325 // Look in every direction until an obstacle (to jump) is met
326 for (const step of V.steps[V.ROOK]) {
327 let i = x + step[0];
328 let j = y + step[1];
329 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
330 i += step[0];
331 j += step[1];
332 }
333 // Then, search for an enemy (if jumped piece isn't a cannon)
334 if (V.OnBoard(i, j) && this.getPiece(i, j) != V.CANNON) {
335 i += step[0];
336 j += step[1];
337 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
338 moves.push(this.getBasicMove([x, y], [i, j]));
339 i += step[0];
340 j += step[1];
341 }
342 if (
343 V.OnBoard(i, j) &&
344 this.getColor(i, j) == oppCol &&
345 this.getPiece(i, j) != V.CANNON
346 ) {
347 moves.push(this.getBasicMove([x, y], [i, j]));
348 }
349 }
350 }
351 if ([3, 5].includes(y) && [0, 2, 7, 9].includes(x)) {
352 // In a corner of a palace: hop over next obstacle if possible
353 const step = [[0, 7].includes(x) ? 1 : -1, 4 - y];
354 const [x1, y1] = [x + step[0], y + step[1]];
355 const [x2, y2] = [x + 2 * step[0], y + 2 * step[1]];
356 if (
357 this.board[x1][y1] != V.EMPTY &&
358 this.getPiece(x1, y1) != V.CANNON &&
359 (
360 this.board[x2][y2] == V.EMPTY ||
361 (
362 this.getColor(x2, y2) == oppCol &&
363 this.getPiece(x2, y2) != V.CANNON
364 )
365 )
366 ) {
367 moves.push(this.getBasicMove([x, y], [x2, y2]));
368 }
369 }
370 return moves;
371 }
372
373 // (King) Never attacked by advisor, since it stays in the palace
374 isAttacked(sq, color) {
375 return (
376 this.isAttackedByPawn(sq, color) ||
377 this.isAttackedByRook(sq, color) ||
378 this.isAttackedByKnight(sq, color) ||
379 this.isAttackedByElephant(sq, color) ||
380 this.isAttackedByCannon(sq, color)
381 );
382 }
383
384 onPalaceDiagonal([x, y]) {
385 return (
386 (y == 4 && [1, 8].includes(x)) ||
387 ([3, 5].includes(y) && [0, 2, 7, 9].includes(x))
388 );
389 }
390
391 isAttackedByPawn([x, y], color) {
392 const shiftX = (color == 'w' ? 1 : -1); //shift from king
393 if (super.isAttackedBySlideNJump(
394 [x, y], color, V.PAWN, [[shiftX, 0], [0, 1], [0, -1]], "oneStep")
395 ) {
396 return true;
397 }
398 if (this.onPalaceDiagonal([x, y])) {
399 for (let yStep of [-1, 1]) {
400 const [xx, yy] = [x + shiftX, y + yStep];
401 if (
402 this.onPalaceDiagonal([xx,yy]) &&
403 this.board[xx][yy] != V.EMPTY &&
404 this.getColor(xx, yy) == color &&
405 this.getPiece(xx, yy) == V.PAWN
406 ) {
407 return true;
408 }
409 }
410 }
411 return false;
412 }
413
414 knightStepsFromBishopStep(step) {
415 return [ [2*step[0], step[1]], [step[0], 2*step[1]] ];
416 }
417
418 isAttackedByKnight([x, y], color) {
419 // Check bishop steps: if empty, look continuation knight step
420 let steps = [];
421 for (let s of ChessRules.steps[V.BISHOP]) {
422 const [i, j] = [x + s[0], y + s[1]];
423 if (
424 V.OnBoard(i, j) &&
425 this.board[i][j] == V.EMPTY
426 ) {
427 Array.prototype.push.apply(steps, this.knightStepsFromBishopStep(s));
428 }
429 }
430 return (
431 super.isAttackedBySlideNJump([x, y], color, V.KNIGHT, steps, "oneStep")
432 );
433 }
434
435 elephantStepsFromBishopStep(step) {
436 return [ [3*step[0], 2*step[1]], [2*step[0], 3*step[1]] ];
437 }
438
439 isAttackedByElephant([x, y], color) {
440 // Check bishop steps: if empty, look continuation elephant step
441 let steps = [];
442 for (let s of ChessRules.steps[V.BISHOP]) {
443 const [i1, j1] = [x + s[0], y + s[1]];
444 const [i2, j2] = [x + 2*s[0], y + 2*s[1]];
445 if (
446 V.OnBoard(i2, j2) && this.board[i2][j2] == V.EMPTY &&
447 V.OnBoard(i1, j1) && this.board[i1][j1] == V.EMPTY
448 ) {
449 Array.prototype.push.apply(steps, this.elephantStepsFromBishopStep(s));
450 }
451 }
452 return (
453 super.isAttackedBySlideNJump([x, y], color, V.ELEPHANT, steps, "oneStep")
454 );
455 }
456
457 isAttackedByRook([x, y], color) {
458 if (super.isAttackedByRook([x, y], color)) return true;
459 // Also check diagonals, if inside palace
460 if (this.onPalaceDiagonal([x, y])) {
461 // TODO: next scan is clearly suboptimal
462 for (let s of ChessRules.steps[V.BISHOP]) {
463 for (let i of [1, 2]) {
464 const [xx, yy] = [x + i * s[0], y + i * s[1]];
465 if (
466 V.OnBoard(xx, yy) &&
467 this.onPalaceDiagonal([xx, yy])
468 ) {
469 if (this.board[xx][yy] != V.EMPTY) {
470 if (
471 this.getColor(xx, yy) == color &&
472 this.getPiece(xx, yy) == V.ROOK
473 ) {
474 return true;
475 }
476 break;
477 }
478 }
479 else continue;
480 }
481 }
482 }
483 return false;
484 }
485
486 // NOTE: (mostly) duplicated from Shako (TODO?)
487 isAttackedByCannon([x, y], color) {
488 // Reversed process: is there an obstacle in line,
489 // and a cannon next in the same line?
490 for (const step of V.steps[V.ROOK]) {
491 let [i, j] = [x+step[0], y+step[1]];
492 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
493 i += step[0];
494 j += step[1];
495 }
496 if (V.OnBoard(i, j) && this.getPiece(i, j) != V.CANNON) {
497 // Keep looking in this direction
498 i += step[0];
499 j += step[1];
500 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
501 i += step[0];
502 j += step[1];
503 }
504 if (
505 V.OnBoard(i, j) &&
506 this.getPiece(i, j) == V.CANNON &&
507 this.getColor(i, j) == color
508 ) {
509 return true;
510 }
511 }
512 }
513 return false;
514 }
515
516 getCurrentScore() {
517 if ([this.bikjangFlag, this.passFlag].includes(2)) return "1/2";
518 const color = this.turn;
519 // super.atLeastOneMove() does not consider passing (OK)
520 if (this.underCheck(color) && !super.atLeastOneMove())
521 return (color == "w" ? "0-1" : "1-0");
522 return "*";
523 }
524
525 static get VALUES() {
526 return {
527 p: 2,
528 r: 13,
529 n: 5,
530 e: 3,
531 a: 3,
532 c: 7,
533 k: 1000
534 };
535 }
536
537 static get SEARCH_DEPTH() {
538 return 2;
539 }
540
541 static GenRandInitFen() {
542 // No randomization here (but initial setup choice)
543 return (
544 "rnea1aenr/4k4/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/4K4/RNEA1AENR w 0 00"
545 );
546 }
547
548 play(move) {
549 move.subTurn = this.subTurn; //much easier
550 if (this.movesCount >= 2 || this.subTurn == 2 || move.vanish.length == 0) {
551 this.turn = V.GetOppCol(this.turn);
552 this.subTurn = 1;
553 this.movesCount++;
554 }
555 else this.subTurn = 2;
556 move.flags = JSON.stringify(this.aggregateFlags());
557 V.PlayOnBoard(this.board, move);
558 this.postPlay(move);
559 }
560
561 postPlay(move) {
562 if (move.vanish.length > 0) super.postPlay(move);
563 else if (this.movesCount > 2) this.passFlag++;
564 // Update bikjang flag
565 if (this.kingPos['w'][1] == this.kingPos['b'][1]) {
566 const y = this.kingPos['w'][1];
567 let bikjang = true;
568 for (let x = this.kingPos['b'][0] + 1; x < this.kingPos['w'][0]; x++) {
569 if (this.board[x][y] != V.EMPTY) {
570 bikjang = false;
571 break;
572 }
573 }
574 if (bikjang) this.bikjangFlag++;
575 else this.bikjangFlag = 0;
576 }
577 else this.bikjangFlag = 0;
578 }
579
580 undo(move) {
581 this.disaggregateFlags(JSON.parse(move.flags));
582 V.UndoOnBoard(this.board, move);
583 this.postUndo(move);
584 if (this.movesCount >= 2 || this.subTurn == 1 || move.vanish.length == 0) {
585 this.turn = V.GetOppCol(this.turn);
586 this.movesCount--;
587 }
588 this.subTurn = move.subTurn;
589 }
590
591 postUndo(move) {
592 if (move.vanish.length > 0) super.postUndo(move);
593 }
594
595 getComputerMove() {
596 if (this.movesCount <= 1) {
597 // Special case: swap and pass at random
598 const moves1 = this.getAllValidMoves();
599 const m1 = moves1[randInt(moves1.length)];
600 this.play(m1);
601 if (m1.vanish.length == 0) {
602 this.undo(m1);
603 return m1;
604 }
605 const moves2 = this.getAllValidMoves();
606 const m2 = moves2[randInt(moves2.length)];
607 this.undo(m1);
608 return [m1, m2];
609 }
610 return super.getComputerMove();
611 }
612
613 getNotation(move) {
614 if (move.vanish.length == 0) return "pass";
615 if (move.appear.length == 2) return "S"; //"swap"
616 let notation = super.getNotation(move);
617 if (move.vanish.length == 2 && move.vanish[0].p == V.PAWN)
618 notation = "P" + notation.substr(1);
619 return notation;
620 }
621
622 };