1 import { ChessRules
, Move
, PiPo
} from "@/base_rules";
2 import { randInt
} from "@/utils/alea";
4 export class JanggiRules
extends ChessRules
{
6 static get Monochrome() {
10 static get Notoodark() {
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]]);
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]]);
29 // No castle, but flag: bikjang
30 static get HasCastle() {
34 static get HasEnpassant() {
38 static get ELEPHANT() {
46 static get ADVISOR() {
51 return [V
.PAWN
, V
.ROOK
, V
.KNIGHT
, V
.ELEPHANT
, V
.ADVISOR
, V
.KING
, V
.CANNON
];
59 return { x: 10, y: 9};
62 static IsGoodFlags(flags
) {
63 // bikjang status of last move + pass
64 return !!flags
.match(/^[0-2]{2,2}$/);
68 return [this.bikjangFlag
, this.passFlag
];
71 disaggregateFlags(flags
) {
72 this.bikjangFlag
= flags
[0];
73 this.passFlag
= flags
[1];
77 return this.bikjangFlag
.toString() + this.passFlag
.toString()
81 this.bikjangFlag
= parseInt(fenflags
.charAt(0), 10);
82 this.passFlag
= parseInt(fenflags
.charAt(1), 10);
85 setOtherVariables(fen
) {
86 super.setOtherVariables(fen
);
87 // Sub-turn is useful only at first move...
91 getPotentialMovesFrom([x
, y
]) {
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)
101 start: { x: this.kingPos
[c
][0], y: this.kingPos
[c
][1] },
102 end: { x: this.kingPos
[oppCol
][0], y: this.kingPos
[oppCol
][1] }
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 (x
== firstRank
&& !!initDestFile
.get(y
)) {
112 const destFile
= initDestFile
.get(y
);
143 start: { x: x
, y: y
},
144 end: { x: x
, y: destFile
}
150 let normalMoves
= [];
151 switch (this.getPiece(x
, y
)) {
153 normalMoves
= this.getPotentialPawnMoves([x
, y
]);
156 normalMoves
= this.getPotentialRookMoves([x
, y
]);
159 normalMoves
= this.getPotentialKnightMoves([x
, y
]);
162 normalMoves
= this.getPotentialElephantMoves([x
, y
]);
165 normalMoves
= this.getPotentialAdvisorMoves([x
, y
]);
168 normalMoves
= this.getPotentialKingMoves([x
, y
]);
171 normalMoves
= this.getPotentialCannonMoves([x
, y
]);
174 Array
.prototype.push
.apply(moves
, normalMoves
);
179 getPotentialPawnMoves([x
, y
]) {
180 const c
= this.getColor(x
, y
);
181 const oppCol
= V
.GetOppCol(c
);
182 const shiftX
= (c
== 'w' ? -1 : 1);
183 const rank23
= (oppCol
== 'w' ? [8, 7] : [1, 2]);
184 let steps
= [[shiftX
, 0], [0, -1], [0, 1]];
185 // Diagonal moves inside enemy palace:
186 if (y
== 4 && x
== rank23
[0])
187 Array
.prototype.push
.apply(steps
, [[shiftX
, 1], [shiftX
, -1]]);
188 else if (x
== rank23
[1]) {
189 if (y
== 3) steps
.push([shiftX
, 1]);
190 else if (y
== 5) steps
.push([shiftX
, -1]);
192 return super.getSlideNJumpMoves([x
, y
], steps
, "oneStep");
195 knightStepsFromRookStep(step
) {
196 if (step
[0] == 0) return [ [1, 2*step
[1]], [-1, 2*step
[1]] ];
197 return [ [2*step
[0], 1], [2*step
[0], -1] ];
200 getPotentialKnightMoves([x
, y
]) {
202 for (let rookStep
of ChessRules
.steps
[V
.ROOK
]) {
203 const [i
, j
] = [x
+ rookStep
[0], y
+ rookStep
[1]];
204 if (V
.OnBoard(i
, j
) && this.board
[i
][j
] == V
.EMPTY
) {
205 Array
.prototype.push
.apply(steps
,
206 // These moves might be impossible, but need to be checked:
207 this.knightStepsFromRookStep(rookStep
));
210 return super.getSlideNJumpMoves([x
, y
], steps
, "oneStep");
213 elephantStepsFromRookStep(step
) {
214 if (step
[0] == 0) return [ [2, 3*step
[1]], [-2, 3*step
[1]] ];
215 return [ [3*step
[0], 2], [3*step
[0], -2] ];
218 getPotentialElephantMoves([x
, y
]) {
220 for (let rookStep
of ChessRules
.steps
[V
.ROOK
]) {
221 const eSteps
= this.elephantStepsFromRookStep(rookStep
);
222 const [i
, j
] = [x
+ rookStep
[0], y
+ rookStep
[1]];
223 if (V
.OnBoard(i
, j
) && this.board
[i
][j
] == V
.EMPTY
) {
224 // Check second crossing:
225 const knightSteps
= this.knightStepsFromRookStep(rookStep
);
226 for (let k
of [0, 1]) {
227 const [ii
, jj
] = [x
+ knightSteps
[k
][0], y
+ knightSteps
[k
][1]];
228 if (V
.OnBoard(ii
, jj
) && this.board
[ii
][jj
] == V
.EMPTY
)
229 steps
.push(eSteps
[k
]); //ok: same ordering
233 return super.getSlideNJumpMoves([x
, y
], steps
, "oneStep");
236 palacePeopleMoves([x
, y
]) {
237 const c
= this.getColor(x
, y
);
240 if (x
< (c
== 'w' ? 9 : 2)) steps
.push([1, 0]);
241 if (x
> (c
== 'w' ? 7 : 0)) steps
.push([-1, 0]);
242 if (y
> 3) steps
.push([0, -1]);
243 if (y
< 5) steps
.push([0, 1]);
244 // Diagonal steps, if in the middle or corner:
248 (c
== 'w' && x
!= 8) ||
252 // In a corner: maximum one diagonal step available
254 const direction
= (c
== 'w' ? -1 : 1);
255 if ((c
== 'w' && x
== 9) || (c
== 'b' && x
== 0)) {
257 if (y
== 3) step
= [direction
, 1];
258 else step
= [direction
, -1];
260 else if ((c
== 'w' && x
== 7) || (c
== 'b' && x
== 2)) {
262 if (y
== 3) step
= [-direction
, 1];
263 else step
= [-direction
, -1];
270 (c
== 'w' && x
== 8) ||
274 // At the middle: all directions available
275 Array
.prototype.push
.apply(steps
, ChessRules
.steps
[V
.BISHOP
]);
277 return super.getSlideNJumpMoves([x
, y
], steps
, "oneStep");
280 getPotentialAdvisorMoves(sq
) {
281 return this.palacePeopleMoves(sq
);
284 getPotentialKingMoves(sq
) {
285 return this.palacePeopleMoves(sq
);
288 getPotentialRookMoves([x
, y
]) {
289 let moves
= super.getPotentialRookMoves([x
, y
]);
290 if ([3, 5].includes(y
) && [0, 2, 7, 9].includes(x
)) {
291 // In a corner of a palace: move along diagonal
292 const step
= [[0, 7].includes(x
) ? 1 : -1, 4 - y
];
293 const oppCol
= V
.GetOppCol(this.getColor(x
, y
));
294 for (let i
of [1, 2]) {
295 const [xx
, yy
] = [x
+ i
* step
[0], y
+ i
* step
[1]];
296 if (this.board
[xx
][yy
] == V
.EMPTY
)
297 moves
.push(this.getBasicMove([x
, y
], [xx
, yy
]));
299 if (this.getColor(xx
, yy
) == oppCol
)
300 moves
.push(this.getBasicMove([x
, y
], [xx
, yy
]));
305 else if (y
== 4 && [1, 8].includes(x
)) {
306 // In the middle of a palace: 4 one-diagonal-step to check
307 Array
.prototype.push
.apply(
309 super.getSlideNJumpMoves([x
, y
],
310 ChessRules
.steps
[V
.BISHOP
],
317 // NOTE: (mostly) duplicated from Shako (TODO?)
318 getPotentialCannonMoves([x
, y
]) {
319 const oppCol
= V
.GetOppCol(this.turn
);
321 // Look in every direction until an obstacle (to jump) is met
322 for (const step
of V
.steps
[V
.ROOK
]) {
325 while (V
.OnBoard(i
, j
) && this.board
[i
][j
] == V
.EMPTY
) {
329 // Then, search for an enemy (if jumped piece isn't a cannon)
330 if (V
.OnBoard(i
, j
) && this.getPiece(i
, j
) != V
.CANNON
) {
333 while (V
.OnBoard(i
, j
) && this.board
[i
][j
] == V
.EMPTY
) {
334 moves
.push(this.getBasicMove([x
, y
], [i
, j
]));
340 this.getColor(i
, j
) == oppCol
&&
341 this.getPiece(i
, j
) != V
.CANNON
343 moves
.push(this.getBasicMove([x
, y
], [i
, j
]));
347 if ([3, 5].includes(y
) && [0, 2, 7, 9].includes(x
)) {
348 // In a corner of a palace: hop over next obstacle if possible
349 const step
= [[0, 7].includes(x
) ? 1 : -1, 4 - y
];
350 const [x1
, y1
] = [x
+ step
[0], y
+ step
[1]];
351 const [x2
, y2
] = [x
+ 2 * step
[0], y
+ 2 * step
[1]];
353 this.board
[x1
][y1
] != V
.EMPTY
&&
354 this.getPiece(x1
, y1
) != V
.CANNON
&&
356 this.board
[x2
][y2
] == V
.EMPTY
||
358 this.getColor(x2
, y2
) == oppCol
&&
359 this.getPiece(x2
, y2
) != V
.CANNON
363 moves
.push(this.getBasicMove([x
, y
], [x2
, y2
]));
369 // (King) Never attacked by advisor, since it stays in the palace
370 isAttacked(sq
, color
) {
372 this.isAttackedByPawn(sq
, color
) ||
373 this.isAttackedByRook(sq
, color
) ||
374 this.isAttackedByKnight(sq
, color
) ||
375 this.isAttackedByElephant(sq
, color
) ||
376 this.isAttackedByCannon(sq
, color
)
380 onPalaceDiagonal([x
, y
]) {
382 (y
== 4 && [1, 8].includes(x
)) ||
383 ([3, 5].includes(y
) && [0, 2, 7, 9].includes(x
))
387 isAttackedByPawn([x
, y
], color
) {
388 const shiftX
= (color
== 'w' ? 1 : -1); //shift from king
389 if (super.isAttackedBySlideNJump(
390 [x
, y
], color
, V
.PAWN
, [[shiftX
, 0], [0, 1], [0, -1]], "oneStep")
394 if (this.onPalaceDiagonal([x
, y
])) {
395 for (let yStep
of [-1, 1]) {
396 const [xx
, yy
] = [x
+ shiftX
, y
+ yStep
];
398 this.onPalaceDiagonal([xx
,yy
]) &&
399 this.board
[xx
][yy
] != V
.EMPTY
&&
400 this.getColor(xx
, yy
) == color
&&
401 this.getPiece(xx
, yy
) == V
.PAWN
410 knightStepsFromBishopStep(step
) {
411 return [ [2*step
[0], step
[1]], [step
[0], 2*step
[1]] ];
414 isAttackedByKnight([x
, y
], color
) {
415 // Check bishop steps: if empty, look continuation knight step
417 for (let s
of ChessRules
.steps
[V
.BISHOP
]) {
418 const [i
, j
] = [x
+ s
[0], y
+ s
[1]];
421 this.board
[i
][j
] == V
.EMPTY
423 Array
.prototype.push
.apply(steps
, this.knightStepsFromBishopStep(s
));
427 super.isAttackedBySlideNJump([x
, y
], color
, V
.KNIGHT
, steps
, "oneStep")
431 elephantStepsFromBishopStep(step
) {
432 return [ [3*step
[0], 2*step
[1]], [2*step
[0], 3*step
[1]] ];
435 isAttackedByElephant([x
, y
], color
) {
436 // Check bishop steps: if empty, look continuation elephant step
438 for (let s
of ChessRules
.steps
[V
.BISHOP
]) {
439 const [i1
, j1
] = [x
+ s
[0], y
+ s
[1]];
440 const [i2
, j2
] = [x
+ 2*s
[0], y
+ 2*s
[1]];
442 V
.OnBoard(i2
, j2
) && this.board
[i2
][j2
] == V
.EMPTY
&&
443 V
.OnBoard(i1
, j1
) && this.board
[i1
][j1
] == V
.EMPTY
445 Array
.prototype.push
.apply(steps
, this.elephantStepsFromBishopStep(s
));
449 super.isAttackedBySlideNJump([x
, y
], color
, V
.ELEPHANT
, steps
, "oneStep")
453 isAttackedByRook([x
, y
], color
) {
454 if (super.isAttackedByRook([x
, y
], color
)) return true;
455 // Also check diagonals, if inside palace
456 if (this.onPalaceDiagonal([x
, y
])) {
457 // TODO: next scan is clearly suboptimal
458 for (let s
of ChessRules
.steps
[V
.BISHOP
]) {
459 for (let i
of [1, 2]) {
460 const [xx
, yy
] = [x
+ i
* s
[0], y
+ i
* s
[1]];
463 this.onPalaceDiagonal([xx
, yy
])
465 if (this.board
[xx
][yy
] != V
.EMPTY
) {
467 this.getColor(xx
, yy
) == color
&&
468 this.getPiece(xx
, yy
) == V
.ROOK
482 // NOTE: (mostly) duplicated from Shako (TODO?)
483 isAttackedByCannon([x
, y
], color
) {
484 // Reversed process: is there an obstacle in line,
485 // and a cannon next in the same line?
486 for (const step
of V
.steps
[V
.ROOK
]) {
487 let [i
, j
] = [x
+step
[0], y
+step
[1]];
488 while (V
.OnBoard(i
, j
) && this.board
[i
][j
] == V
.EMPTY
) {
492 if (V
.OnBoard(i
, j
) && this.getPiece(i
, j
) != V
.CANNON
) {
493 // Keep looking in this direction
496 while (V
.OnBoard(i
, j
) && this.board
[i
][j
] == V
.EMPTY
) {
502 this.getPiece(i
, j
) == V
.CANNON
&&
503 this.getColor(i
, j
) == color
513 if ([this.bikjangFlag
, this.passFlag
].includes(2)) return "1/2";
514 const color
= this.turn
;
515 // super.atLeastOneMove() does not consider passing (OK)
516 if (this.underCheck(color
) && !super.atLeastOneMove())
517 return (color
== "w" ? "0-1" : "1-0");
521 static get VALUES() {
533 static get SEARCH_DEPTH() {
537 static GenRandInitFen() {
538 // No randomization here (but initial setup choice)
540 "rnea1aenr/4k4/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/4K4/RNEA1AENR w 0 00"
545 move.subTurn
= this.subTurn
; //much easier
546 if (this.movesCount
>= 2 || this.subTurn
== 2 || move.vanish
.length
== 0) {
547 this.turn
= V
.GetOppCol(this.turn
);
551 else this.subTurn
= 2;
552 move.flags
= JSON
.stringify(this.aggregateFlags());
553 V
.PlayOnBoard(this.board
, move);
558 if (move.vanish
.length
> 0) super.postPlay(move);
559 else if (this.movesCount
> 2) this.passFlag
++;
560 // Update bikjang flag
561 if (this.kingPos
['w'][1] == this.kingPos
['b'][1]) {
562 const y
= this.kingPos
['w'][1];
564 for (let x
= this.kingPos
['b'][0] + 1; x
< this.kingPos
['w'][0]; x
++) {
565 if (this.board
[x
][y
] != V
.EMPTY
) {
570 if (bikjang
) this.bikjangFlag
++;
571 else this.bikjangFlag
= 0;
573 else this.bikjangFlag
= 0;
577 this.disaggregateFlags(JSON
.parse(move.flags
));
578 V
.UndoOnBoard(this.board
, move);
580 if (this.movesCount
>= 2 || this.subTurn
== 1 || move.vanish
.length
== 0) {
581 this.turn
= V
.GetOppCol(this.turn
);
584 this.subTurn
= move.subTurn
;
588 if (move.vanish
.length
> 0) super.postUndo(move);
592 if (this.movesCount
<= 1) {
593 // Special case: swap and pass at random
594 const moves1
= this.getAllValidMoves();
595 const m1
= moves1
[randInt(moves1
.length
)];
597 if (m1
.vanish
.length
== 0) {
601 const moves2
= this.getAllValidMoves();
602 const m2
= moves2
[randInt(moves2
.length
)];
606 return super.getComputerMove();
610 if (move.vanish
.length
== 0) return "pass";
611 if (move.appear
.length
== 2) return "S"; //"swap"
612 let notation
= super.getNotation(move);
613 if (move.vanish
.length
== 2 && move.vanish
[0].p
== V
.PAWN
)
614 notation
= "P" + notation
.substr(1);