Fix Titan (king tracking)
[vchess.git] / client / src / variants / Apocalypse.js
1 import { ChessRules } from "@/base_rules";
2 import { randInt } from "@/utils/alea";
3
4 export class ApocalypseRules extends ChessRules {
5
6 static get PawnSpecs() {
7 return Object.assign(
8 {},
9 ChessRules.PawnSpecs,
10 {
11 twoSquares: false,
12 promotions: [V.KNIGHT]
13 }
14 );
15 }
16
17 static get SomeHiddenMoves() {
18 return true;
19 }
20
21 static get HasCastle() {
22 return false;
23 }
24
25 static get HasEnpassant() {
26 return false;
27 }
28
29 static get CanAnalyze() {
30 return false;
31 }
32
33 static get ShowMoves() {
34 return "byrow";
35 }
36
37 getPPpath(m) {
38 // Show the piece taken, if any, and not multiple pawns:
39 if (m.vanish.length == 1) return "Apocalypse/empty";
40 return m.vanish[1].c + m.vanish[1].p;
41 }
42
43 static get PIECES() {
44 return [V.PAWN, V.KNIGHT];
45 }
46
47 static IsGoodPosition(position) {
48 if (position.length == 0) return false;
49 const rows = position.split("/");
50 if (rows.length != V.size.x) return false;
51 // At least one pawn per color
52 let pawns = { "p": 0, "P": 0 };
53 for (let row of rows) {
54 let sumElts = 0;
55 for (let i = 0; i < row.length; i++) {
56 if (['P','p'].includes(row[i])) pawns[row[i]]++;
57 if (V.PIECES.includes(row[i].toLowerCase())) sumElts++;
58 else {
59 const num = parseInt(row[i], 10);
60 if (isNaN(num)) return false;
61 sumElts += num;
62 }
63 }
64 if (sumElts != V.size.y) return false;
65 }
66 if (Object.values(pawns).some(v => v == 0))
67 return false;
68 return true;
69 }
70
71 static IsGoodFen(fen) {
72 if (!ChessRules.IsGoodFen(fen)) return false;
73 const fenParsed = V.ParseFen(fen);
74 // 4) Check whiteMove
75 if (
76 (
77 fenParsed.turn == "b" &&
78 // NOTE: do not check really JSON stringified move...
79 (!fenParsed.whiteMove || fenParsed.whiteMove == "-")
80 )
81 ||
82 (fenParsed.turn == "w" && fenParsed.whiteMove != "-")
83 ) {
84 return false;
85 }
86 return true;
87 }
88
89 static IsGoodFlags(flags) {
90 return !!flags.match(/^[0-2]{2,2}$/);
91 }
92
93 aggregateFlags() {
94 return this.penaltyFlags;
95 }
96
97 disaggregateFlags(flags) {
98 this.penaltyFlags = flags;
99 }
100
101 static ParseFen(fen) {
102 const fenParts = fen.split(" ");
103 return Object.assign(
104 ChessRules.ParseFen(fen),
105 { whiteMove: fenParts[4] }
106 );
107 }
108
109 static get size() {
110 return { x: 5, y: 5 };
111 }
112
113 static GenRandInitFen() {
114 return "npppn/p3p/5/P3P/NPPPN w 0 00 -";
115 }
116
117 getFen() {
118 return super.getFen() + " " + this.getWhitemoveFen();
119 }
120
121 getFenForRepeat() {
122 return super.getFenForRepeat() + "_" + this.getWhitemoveFen();
123 }
124
125 getFlagsFen() {
126 return (
127 this.penaltyFlags['w'].toString() + this.penaltyFlags['b'].toString()
128 );
129 }
130
131 setOtherVariables(fen) {
132 const parsedFen = V.ParseFen(fen);
133 this.setFlags(parsedFen.flags);
134 // Also init whiteMove
135 this.whiteMove =
136 parsedFen.whiteMove != "-"
137 ? JSON.parse(parsedFen.whiteMove)
138 : null;
139 }
140
141 setFlags(fenflags) {
142 this.penaltyFlags = {
143 'w': parseInt(fenflags[0], 10),
144 'b': parseInt(fenflags[1], 10)
145 };
146 }
147
148 getWhitemoveFen() {
149 if (!this.whiteMove) return "-";
150 return JSON.stringify({
151 start: this.whiteMove.start,
152 end: this.whiteMove.end,
153 appear: this.whiteMove.appear,
154 vanish: this.whiteMove.vanish
155 });
156 }
157
158 getSpeculations(moves, sq) {
159 let moveSet = {};
160 moves.forEach(m => {
161 const mHash = "m" + m.start.x + m.start.y + m.end.x + m.end.y;
162 moveSet[mHash] = true;
163 });
164 const color = this.turn;
165 this.turn = V.GetOppCol(color);
166 const oppMoves = super.getAllValidMoves();
167 this.turn = color;
168 // For each opponent's move, generate valid moves [from sq if same color]
169 let speculations = [];
170 oppMoves.forEach(m => {
171 V.PlayOnBoard(this.board, m);
172 const newValidMoves =
173 !!sq
174 ? (
175 this.getColor(sq[0], sq[1]) == color
176 ? super.getPotentialMovesFrom(sq)
177 : []
178 )
179 : super.getAllValidMoves();
180 newValidMoves.forEach(vm => {
181 const mHash = "m" + vm.start.x + vm.start.y + vm.end.x + vm.end.y;
182 if (!moveSet[mHash]) {
183 moveSet[mHash] = true;
184 vm.end.illegal = true; //potentially illegal!
185 speculations.push(vm);
186 }
187 });
188 V.UndoOnBoard(this.board, m);
189 });
190 return speculations;
191 }
192
193 getPossibleMovesFrom([x, y]) {
194 const possibleMoves = super.getPotentialMovesFrom([x, y])
195 // Augment potential moves with opponent's moves speculation:
196 return possibleMoves.concat(this.getSpeculations(possibleMoves, [x, y]));
197 }
198
199 getAllValidMoves() {
200 // Return possible moves + potentially valid moves
201 const validMoves = super.getAllValidMoves();
202 return validMoves.concat(this.getSpeculations(validMoves));
203 }
204
205 addPawnMoves([x1, y1], [x2, y2], moves) {
206 let finalPieces = [V.PAWN];
207 const color = this.turn;
208 const lastRank = (color == "w" ? 0 : V.size.x - 1);
209 if (x2 == lastRank) {
210 // If 0 or 1 horsemen, promote in knight
211 let knightCounter = 0;
212 let emptySquares = [];
213 for (let i = 0; i < V.size.x; i++) {
214 for (let j = 0; j < V.size.y; j++) {
215 if (this.board[i][j] == V.EMPTY) emptySquares.push([i, j]);
216 else if (
217 this.getColor(i, j) == color &&
218 this.getPiece(i, j) == V.KNIGHT
219 ) {
220 knightCounter++;
221 }
222 }
223 }
224 if (knightCounter <= 1) finalPieces = [V.KNIGHT];
225 else {
226 // Generate all possible landings, maybe capturing something on the way
227 let capture = undefined;
228 if (this.board[x2][y2] != V.EMPTY) {
229 capture = JSON.parse(JSON.stringify({
230 x: x2,
231 y: y2,
232 c: this.getColor(x2, y2),
233 p: this.getPiece(x2, y2)
234 }));
235 }
236 emptySquares.forEach(sq => {
237 if (sq[0] != lastRank) {
238 let newMove = this.getBasicMove([x1, y1], [sq[0], sq[1]]);
239 if (!!capture) newMove.vanish.push(capture);
240 moves.push(newMove);
241 }
242 });
243 return;
244 }
245 }
246 let tr = null;
247 for (let piece of finalPieces) {
248 tr = (piece != V.PAWN ? { c: color, p: piece } : null);
249 moves.push(this.getBasicMove([x1, y1], [x2, y2], tr));
250 }
251 }
252
253 filterValid(moves) {
254 // No checks:
255 return moves;
256 }
257
258 atLeastOneMove(color) {
259 const curTurn = this.turn;
260 this.turn = color;
261 const res = super.atLeastOneMove();
262 this.turn = curTurn;
263 return res;
264 }
265
266 // White and black (partial) moves were played: merge
267 resolveSynchroneMove(move) {
268 let m1 = this.whiteMove;
269 let m2 = move;
270 const movingLikeCapture = (m) => {
271 const shift = (m.vanish[0].c == 'w' ? -1 : 1);
272 return (
273 m.start.x + shift == m.end.x &&
274 Math.abs(m.end.y - m.start.y) == 1
275 );
276 };
277 const isPossible = (m, other) => {
278 return (
279 (
280 m.vanish[0].p == V.KNIGHT &&
281 (
282 m.vanish.length == 1 ||
283 m.vanish[1].c != m.vanish[0].c ||
284 // Self-capture attempt
285 (
286 !other.end.illegal &&
287 other.end.x == m.end.x &&
288 other.end.y == m.end.y
289 )
290 )
291 )
292 ||
293 (
294 m.vanish[0].p == V.PAWN &&
295 !other.end.illegal &&
296 (
297 (
298 // Promotion attempt
299 m.end.x == (m.vanish[0].c == "w" ? 0 : V.size.x - 1) &&
300 other.vanish.length == 2 &&
301 other.vanish[1].p == V.KNIGHT &&
302 other.vanish[1].c == m.vanish[0].c
303 )
304 ||
305 (
306 // Moving attempt
307 !movingLikeCapture(m) &&
308 other.start.x == m.end.x &&
309 other.start.y == m.end.y
310 )
311 ||
312 (
313 // Capture attempt
314 movingLikeCapture(m) &&
315 other.end.x == m.end.x &&
316 other.end.y == m.end.y
317 )
318 )
319 )
320 );
321 };
322 if (!!m1.end.illegal && !isPossible(m1, m2)) {
323 // Either an anticipated capture of something which didn't move
324 // (or not to the right square), or a push through blocus.
325 // ==> Just discard the move, and add a penalty point
326 this.penaltyFlags[m1.vanish[0].c]++;
327 m1.isNull = true;
328 }
329 if (!!m2.end.illegal && !isPossible(m2, m1)) {
330 this.penaltyFlags[m2.vanish[0].c]++;
331 m2.isNull = true;
332 }
333 if (!!m1.isNull) m1 = null;
334 if (!!m2.isNull) m2 = null;
335 // If one move is illegal, just execute the other
336 if (!m1 && !!m2) return m2;
337 if (!m2 && !!m1) return m1;
338 // For PlayOnBoard (no need for start / end, irrelevant)
339 let smove = {
340 appear: [],
341 vanish: []
342 };
343 if (!m1 && !m2) return smove;
344 // Both moves are now legal or at least possible:
345 smove.vanish.push(m1.vanish[0]);
346 smove.vanish.push(m2.vanish[0]);
347 if ((m1.end.x != m2.end.x) || (m1.end.y != m2.end.y)) {
348 // Easy case: two independant moves
349 smove.appear.push(m1.appear[0]);
350 smove.appear.push(m2.appear[0]);
351 // "Captured" pieces may have moved:
352 if (
353 m1.vanish.length == 2 &&
354 (
355 m1.vanish[1].x != m2.start.x ||
356 m1.vanish[1].y != m2.start.y
357 )
358 ) {
359 smove.vanish.push(m1.vanish[1]);
360 }
361 if (
362 m2.vanish.length == 2 &&
363 (
364 m2.vanish[1].x != m1.start.x ||
365 m2.vanish[1].y != m1.start.y
366 )
367 ) {
368 smove.vanish.push(m2.vanish[1]);
369 }
370 } else {
371 // Collision: priority to the anticipated capture, if any.
372 // If ex-aequo: knight wins (higher risk), or both disappears.
373 // Then, priority to the knight vs pawn: remains.
374 // Finally: both disappears.
375 let remain = null;
376 const p1 = m1.vanish[0].p;
377 const p2 = m2.vanish[0].p;
378 if (!!m1.end.illegal && !m2.end.illegal) remain = { c: 'w', p: p1 };
379 else if (!!m2.end.illegal && !m1.end.illegal) remain = { c: 'b', p: p2 };
380 if (!remain) {
381 // Either both are illegal or both are legal
382 if (p1 == V.KNIGHT && p2 == V.PAWN) remain = { c: 'w', p: p1 };
383 else if (p2 == V.KNIGHT && p1 == V.PAWN) remain = { c: 'b', p: p2 };
384 // If remain is still null: same type same risk, both disappear
385 }
386 if (!!remain) {
387 smove.appear.push({
388 x: m1.end.x,
389 y: m1.end.y,
390 p: remain.p,
391 c: remain.c
392 });
393 }
394 }
395 return smove;
396 }
397
398 play(move) {
399 // Do not play on board (would reveal the move...)
400 move.flags = JSON.stringify(this.aggregateFlags());
401 this.turn = V.GetOppCol(this.turn);
402 this.movesCount++;
403 this.postPlay(move);
404 }
405
406 postPlay(move) {
407 if (this.turn == 'b') {
408 // NOTE: whiteMove is used read-only, so no need to copy
409 this.whiteMove = move;
410 return;
411 }
412 // A full turn just ended:
413 const smove = this.resolveSynchroneMove(move);
414 V.PlayOnBoard(this.board, smove);
415 move.whiteMove = this.whiteMove; //for undo
416 this.whiteMove = null;
417 move.smove = smove;
418 }
419
420 undo(move) {
421 this.disaggregateFlags(JSON.parse(move.flags));
422 if (this.turn == 'w')
423 // Back to the middle of the move
424 V.UndoOnBoard(this.board, move.smove);
425 this.turn = V.GetOppCol(this.turn);
426 this.movesCount--;
427 this.postUndo(move);
428 }
429
430 postUndo(move) {
431 if (this.turn == 'w') this.whiteMove = null;
432 else this.whiteMove = move.whiteMove;
433 }
434
435 getCheckSquares() {
436 return [];
437 }
438
439 getCurrentScore() {
440 if (this.turn == 'b')
441 // Turn (white + black) not over yet
442 return "*";
443 // Count footmen: if a side has none, it loses
444 let fmCount = { 'w': 0, 'b': 0 };
445 for (let i=0; i<5; i++) {
446 for (let j=0; j<5; j++) {
447 if (this.board[i][j] != V.EMPTY && this.getPiece(i, j) == V.PAWN)
448 fmCount[this.getColor(i, j)]++;
449 }
450 }
451 if (Object.values(fmCount).some(v => v == 0)) {
452 if (fmCount['w'] == 0 && fmCount['b'] == 0)
453 // Everyone died
454 return "1/2";
455 if (fmCount['w'] == 0) return "0-1";
456 return "1-0"; //fmCount['b'] == 0
457 }
458 // Check penaltyFlags: if a side has 2 or more, it loses
459 if (Object.values(this.penaltyFlags).every(v => v == 2)) return "1/2";
460 if (this.penaltyFlags['w'] == 2) return "0-1";
461 if (this.penaltyFlags['b'] == 2) return "1-0";
462 if (!this.atLeastOneMove('w') || !this.atLeastOneMove('b'))
463 // Stalemate (should be very rare)
464 return "1/2";
465 return "*";
466 }
467
468 getComputerMove() {
469 const maxeval = V.INFINITY;
470 const color = this.turn;
471 let moves = this.getAllValidMoves();
472 if (moves.length == 0)
473 // TODO: this situation should not happen
474 return null;
475
476 // Rank moves at depth 1:
477 let validMoves = [];
478 let illegalMoves = [];
479 moves.forEach(m => {
480 // Warning: m might be illegal!
481 if (!m.end.illegal) {
482 V.PlayOnBoard(this.board, m);
483 m.eval = this.evalPosition();
484 V.UndoOnBoard(this.board, m);
485 validMoves.push(m);
486 } else illegalMoves.push(m);
487 });
488
489 const illegalRatio = illegalMoves.length / moves.length;
490 if (Math.random() < illegalRatio)
491 // Return a random illegal move
492 return illegalMoves[randInt(illegalMoves.length)];
493
494 validMoves.sort((a, b) => {
495 return (color == "w" ? 1 : -1) * (b.eval - a.eval);
496 });
497 let candidates = [0];
498 for (
499 let i = 1;
500 i < validMoves.length && validMoves[i].eval == moves[0].eval;
501 i++
502 ) {
503 candidates.push(i);
504 }
505 return validMoves[candidates[randInt(candidates.length)]];
506 }
507
508 getNotation(move) {
509 // Basic system: piece + init + dest square
510 return (
511 (move.vanish[0].p == V.KNIGHT ? "N" : "") +
512 V.CoordsToSquare(move.start) +
513 V.CoordsToSquare(move.end)
514 );
515 }
516
517 };