'update'
[vchess.git] / client / src / variants / Fugue.js
1 import { ChessRules, PiPo, Move } from "@/base_rules";
2 import { ArrayFun } from "@/utils/array";
3 import { shuffle } from "@/utils/alea";
4
5 export class FugueRules extends ChessRules {
6
7 static get HasFlags() {
8 return false;
9 }
10
11 static get HasEnpassant() {
12 return false;
13 }
14
15 static get LoseOnRepetition() {
16 return true;
17 }
18
19 static get IMMOBILIZER() {
20 return 'i';
21 }
22 static get PUSHME_PULLYOU() {
23 return 'u';
24 }
25 static get ARCHER() {
26 return 'a';
27 }
28 static get SHIELD() {
29 return 's';
30 }
31 static get LONG_LEAPER() {
32 return 'l';
33 }
34 static get SWAPPER() {
35 return 'w';
36 }
37
38 static get PIECES() {
39 return [
40 V.PAWN,
41 V.QUEEN,
42 V.KING,
43 V.IMMOBILIZER,
44 V.PUSHME_PULLYOU,
45 V.ARCHER,
46 V.SHIELD,
47 V.LONG_LEAPER,
48 V.SWAPPER
49 ];
50 }
51
52 getPpath(b) {
53 if (['p', 'q', 'k'].includes(b[1])) return b;
54 return "Fugue/" + b;
55 }
56
57 getPPpath(m) {
58 // The only "choice" case is between a swap and a mutual destruction:
59 // show empty square in case of mutual destruction.
60 if (m.appear.length == 0) return "Rococo/empty";
61 return this.getPpath(m.appear[0].c + m.appear[0].p);
62 }
63
64 scanKings(fen) {
65 // No castling, but keep track of kings for faster game end checks
66 this.kingPos = { w: [-1, -1], b: [-1, -1] };
67 const fenParts = fen.split(" ");
68 const position = fenParts[0].split("/");
69 for (let i = 0; i < position.length; i++) {
70 let k = 0;
71 for (let j = 0; j < position[i].length; j++) {
72 switch (position[i].charAt(j)) {
73 case "k":
74 this.kingPos["b"] = [i, k];
75 break;
76 case "K":
77 this.kingPos["w"] = [i, k];
78 break;
79 default: {
80 const num = parseInt(position[i].charAt(j), 10);
81 if (!isNaN(num)) k += num - 1;
82 }
83 }
84 k++;
85 }
86 }
87 }
88
89 // Is piece on square (x,y) immobilized?
90 isImmobilized([x, y]) {
91 const piece = this.getPiece(x, y);
92 if (piece == V.IMMOBILIZER) return false;
93 const oppCol = V.GetOppCol(this.getColor(x, y));
94 const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
95 for (let step of adjacentSteps) {
96 const [i, j] = [x + step[0], y + step[1]];
97 if (
98 V.OnBoard(i, j) &&
99 this.board[i][j] != V.EMPTY &&
100 this.getColor(i, j) == oppCol
101 ) {
102 if (this.getPiece(i, j) == V.IMMOBILIZER) return true;
103 }
104 }
105 return false;
106 }
107
108 isProtected([x, y]) {
109 const color = this.getColor(x, y);
110 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
111 for (let s of steps) {
112 const [i, j] = [x + s[0], y + s[1]];
113 if (
114 V.OnBoard(i, j) &&
115 this.getColor(i, j) == color &&
116 this.getPiece(i, j) == V.SHIELD
117 ) {
118 return true;
119 }
120 }
121 return false;
122 }
123
124 canTake([x1, y1], [x2, y2]) {
125 return (
126 [V.QUEEN, V.KING].includes(this.getPiece(x1, y1)) &&
127 !this.isProtected([x2, y2]) &&
128 this.getColor(x1, y1) != this.getColor(x2, y2)
129 );
130 }
131
132 getPotentialMovesFrom([x, y]) {
133 // Pre-check: is thing on this square immobilized?
134 if (this.isImmobilized([x, y])) return [];
135 const piece = this.getPiece(x, y);
136 let moves = [];
137 switch (piece) {
138 case V.PAWN: return this.getPotentialPawnMoves([x, y]);
139 case V.IMMOBILIZER: return this.getPotentialImmobilizerMoves([x, y]);
140 case V.PUSHME_PULLYOU: return this.getPotentialPushmePullyuMoves([x, y]);
141 case V.ARCHER: return this.getPotentialArcherMoves([x, y]);
142 case V.SHIELD: return this.getPotentialShieldMoves([x, y]);
143 case V.KING: return this.getPotentialKingMoves([x, y]);
144 case V.QUEEN: return super.getPotentialQueenMoves([x, y]);
145 case V.LONG_LEAPER: return this.getPotentialLongLeaperMoves([x, y]);
146 case V.SWAPPER: return this.getPotentialSwapperMoves([x, y]);
147 }
148 }
149
150 // "Cannon/grasshopper pawn"
151 getPotentialPawnMoves([x, y]) {
152 const c = this.turn;
153 const oppCol = V.GetOppCol(c);
154 const lastRank = (c == 'w' ? 0 : 7);
155 let canResurect = {
156 [V.QUEEN]: true,
157 [V.IMMOBILIZER]: true,
158 [V.PUSHME_PULLYOU]: true,
159 [V.ARCHER]: true,
160 [V.SHIELD]: true,
161 [V.LONG_LEAPER]: true,
162 [V.SWAPPER]: true
163 };
164 for (let i = 0; i < 8; i++) {
165 for (let j = 0; j < 8; j++) {
166 if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == c) {
167 const pIJ = this.getPiece(i, j);
168 if (![V.PAWN, V.KING].includes(pIJ)) canResurect[pIJ] = false;
169 }
170 }
171 }
172 let moves = [];
173 const addPromotions = sq => {
174 // Optional promotion
175 Object.keys(canResurect).forEach(p => {
176 if (canResurect[p]) {
177 moves.push(
178 this.getBasicMove([x, y], [sq[0], sq[1]], { c: c, p: p }));
179 }
180 });
181 }
182 const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
183 adjacentSteps.forEach(step => {
184 const [i, j] = [x + step[0], y + step[1]];
185 if (V.OnBoard(i, j)) {
186 if (this.board[i][j] == V.EMPTY) {
187 moves.push(this.getBasicMove([x, y], [i, j]));
188 if (i == lastRank) addPromotions([i, j]);
189 }
190 else {
191 // Try to leap over:
192 const [ii, jj] = [i + step[0], j + step[1]];
193 if (
194 V.OnBoard(ii, jj) &&
195 (
196 this.board[ii][jj] == V.EMPTY ||
197 this.getColor(ii, jj) == oppCol && !this.isProtected([ii, jj])
198 )
199 ) {
200 moves.push(this.getBasicMove([x, y], [ii, jj]));
201 if (ii == lastRank) addPromotions([ii, jj]);
202 }
203 }
204 }
205 });
206 return moves;
207 }
208
209 getPotentialKingMoves(sq) {
210 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
211 return this.getSlideNJumpMoves(sq, steps, 1);
212 }
213
214 // NOTE: not really captures, but let's keep the name
215 getSwapperCaptures([x, y]) {
216 let moves = [];
217 const oppCol = V.GetOppCol(this.turn);
218 // Simple: if something is visible, we can swap
219 V.steps[V.ROOK].concat(V.steps[V.BISHOP]).forEach(step => {
220 let [i, j] = [x + step[0], y + step[1]];
221 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
222 i += step[0];
223 j += step[1];
224 }
225 if (V.OnBoard(i, j) && this.getColor(i, j) == oppCol) {
226 const oppPiece = this.getPiece(i, j);
227 let m = this.getBasicMove([x, y], [i, j]);
228 m.appear.push(
229 new PiPo({
230 x: x,
231 y: y,
232 c: oppCol,
233 p: this.getPiece(i, j)
234 })
235 );
236 moves.push(m);
237 if (
238 i == x + step[0] && j == y + step[1] &&
239 !this.isProtected([i, j])
240 ) {
241 // Add mutual destruction option:
242 m = new Move({
243 start: { x: x, y: y},
244 end: { x: i, y: j },
245 appear: [],
246 // TODO: is copying necessary here?
247 vanish: JSON.parse(JSON.stringify(m.vanish))
248 });
249 moves.push(m);
250 }
251 }
252 });
253 return moves;
254 }
255
256 getPotentialSwapperMoves(sq) {
257 return (
258 super.getPotentialQueenMoves(sq).concat(this.getSwapperCaptures(sq))
259 );
260 }
261
262 getLongLeaperCaptures([x, y]) {
263 // Look in every direction for captures
264 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
265 const color = this.turn;
266 const oppCol = V.GetOppCol(color);
267 let moves = [];
268 const piece = this.getPiece(x, y);
269 outerLoop: for (let step of steps) {
270 let [i, j] = [x + step[0], y + step[1]];
271 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
272 i += step[0];
273 j += step[1];
274 }
275 if (
276 !V.OnBoard(i, j) ||
277 this.getColor(i, j) == color ||
278 this.isProtected([i, j])
279 ) {
280 continue;
281 }
282 let [ii, jj] = [i + step[0], j + step[1]];
283 const vanished = [
284 new PiPo({ x: x, y: y, c: color, p: piece }),
285 new PiPo({ x: i, y: j, c: oppCol, p: this.getPiece(i, j)})
286 ];
287 while (V.OnBoard(ii, jj) && this.board[ii][jj] == V.EMPTY) {
288 moves.push(
289 new Move({
290 appear: [new PiPo({ x: ii, y: jj, c: color, p: piece })],
291 vanish: JSON.parse(JSON.stringify(vanished)), //TODO: required?
292 start: { x: x, y: y },
293 end: { x: ii, y: jj }
294 })
295 );
296 ii += step[0];
297 jj += step[1];
298 }
299 }
300 return moves;
301 }
302
303 getPotentialLongLeaperMoves(sq) {
304 return (
305 super.getPotentialQueenMoves(sq).concat(this.getLongLeaperCaptures(sq))
306 );
307 }
308
309 completeAndFilterPPcaptures(moves) {
310 if (moves.length == 0) return [];
311 const [x, y] = [moves[0].start.x, moves[0].start.y];
312 const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
313 let capturingDirStart = {};
314 const oppCol = V.GetOppCol(this.turn);
315 // Useful precomputation:
316 adjacentSteps.forEach(step => {
317 const [i, j] = [x + step[0], y + step[1]];
318 if (
319 V.OnBoard(i, j) &&
320 this.board[i][j] != V.EMPTY &&
321 this.getColor(i, j) == oppCol
322 ) {
323 capturingDirStart[step[0] + "_" + step[1]] = {
324 p: this.getPiece(i, j),
325 canTake: !this.isProtected([i, j])
326 };
327 }
328 });
329 moves.forEach(m => {
330 const step = [
331 m.end.x != x ? (m.end.x - x) / Math.abs(m.end.x - x) : 0,
332 m.end.y != y ? (m.end.y - y) / Math.abs(m.end.y - y) : 0
333 ];
334 // TODO: this test should be done only once per direction
335 const capture = capturingDirStart[(-step[0]) + "_" + (-step[1])];
336 if (!!capture && capture.canTake) {
337 const [i, j] = [x - step[0], y - step[1]];
338 m.vanish.push(
339 new PiPo({
340 x: i,
341 y: j,
342 p: capture.p,
343 c: oppCol
344 })
345 );
346 }
347 // Also test the end (advancer effect)
348 const [i, j] = [m.end.x + step[0], m.end.y + step[1]];
349 if (
350 V.OnBoard(i, j) &&
351 this.board[i][j] != V.EMPTY &&
352 this.getColor(i, j) == oppCol &&
353 !this.isProtected([i, j])
354 ) {
355 m.vanish.push(
356 new PiPo({
357 x: i,
358 y: j,
359 p: this.getPiece(i, j),
360 c: oppCol
361 })
362 );
363 }
364 });
365 // Forbid "double captures"
366 return moves.filter(m => m.vanish.length <= 2);
367 }
368
369 getPotentialPushmePullyuMoves(sq) {
370 let moves = super.getPotentialQueenMoves(sq);
371 return this.completeAndFilterPPcaptures(moves);
372 }
373
374 getPotentialImmobilizerMoves(sq) {
375 // Immobilizer doesn't capture
376 return super.getPotentialQueenMoves(sq);
377 }
378
379 getPotentialArcherMoves([x, y]) {
380 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
381 let moves = this.getSlideNJumpMoves([x, y], steps);
382 const c = this.turn;
383 const oppCol = V.GetOppCol(c);
384 // Add captures
385 for (let s of steps) {
386 let [i, j] = [x + s[0], y + s[1]];
387 let stepCounter = 1;
388 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
389 i += s[0];
390 j += s[1];
391 stepCounter++;
392 }
393 if (
394 V.OnBoard(i, j) &&
395 this.getColor(i, j) == oppCol &&
396 !this.isProtected([i, j])
397 ) {
398 let shootOk = (stepCounter <= 2);
399 if (!shootOk) {
400 // try to find a spotting piece:
401 for (let ss of steps) {
402 let [ii, jj] = [i + ss[0], j + ss[1]];
403 if (V.OnBoard(ii, jj)) {
404 if (this.board[ii][jj] != V.EMPTY) {
405 if (this.getColor(ii, jj) == c) {
406 shootOk = true;
407 break;
408 }
409 }
410 else {
411 ii += ss[0];
412 jj += ss[1];
413 if (
414 V.OnBoard(ii, jj) &&
415 this.board[ii][jj] != V.EMPTY &&
416 this.getColor(ii, jj) == c
417 ) {
418 shootOk = true;
419 break;
420 }
421 }
422 }
423 }
424 }
425 if (shootOk) {
426 moves.push(
427 new Move({
428 appear: [],
429 vanish: [
430 new PiPo({ x: i, y: j, c: oppCol, p: this.getPiece(i, j) })
431 ],
432 start: { x: x, y: y },
433 end: { x: i, y: j }
434 })
435 );
436 }
437 }
438 }
439 return moves;
440 }
441
442 getPotentialShieldMoves(sq) {
443 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
444 return this.getSlideNJumpMoves(sq, steps);
445 }
446
447 getCheckSquares() {
448 return [];
449 }
450
451 filterValid(moves) {
452 return moves;
453 }
454
455 getCurrentScore() {
456 const c = this.turn;
457 if (this.kingPos[c][0] < 0) return (c == 'w' ? "0-1" : "1-0");
458 if (this.atLeastOneMove()) return "*";
459 // Stalemate, or checkmate: I lose
460 return (c == 'w' ? "0-1" : "1-0");
461 }
462
463 postPlay(move) {
464 const startIdx = (move.appear.length == 0 ? 0 : 1);
465 for (let i = startIdx; i < move.vanish.length; i++) {
466 const v = move.vanish[i];
467 if (v.p == V.KING) this.kingPos[v.c] = [-1, -1];
468 }
469 // King may have moved, or was swapped
470 for (let a of move.appear) {
471 if (a.p == V.KING) {
472 this.kingPos[a.c] = [a.x, a.y];
473 break;
474 }
475 }
476 }
477
478 postUndo(move) {
479 const startIdx = (move.appear.length == 0 ? 0 : 1);
480 for (let i = startIdx; i < move.vanish.length; i++) {
481 const v = move.vanish[i];
482 if (v.p == V.KING) this.kingPos[v.c] = [v.x, v.y];
483 }
484 // King may have moved, or was swapped
485 for (let i = 0; i < move.appear.length; i++) {
486 const a = move.appear[i];
487 if (a.p == V.KING) {
488 const v = move.vanish[i];
489 this.kingPos[a.c] = [v.x, v.y];
490 break;
491 }
492 }
493 }
494
495 static GenRandInitFen(options) {
496 if (options.randomness == 0) {
497 return (
498 "wlqksaui/pppppppp/8/8/8/8/PPPPPPPP/IUASKQLW w 0"
499 );
500 }
501
502 let pieces = { w: new Array(8), b: new Array(8) };
503 // Shuffle pieces on first and last rank
504 for (let c of ["w", "b"]) {
505 if (c == 'b' && options.randomness == 1) {
506 pieces['b'] = pieces['w'];
507 break;
508 }
509
510 // Get random squares for every piece, totally freely
511 let positions = shuffle(ArrayFun.range(8));
512 const composition = ['w', 'l', 'q', 'k', 's', 'a', 'u', 'i'];
513 for (let i = 0; i < 8; i++) pieces[c][positions[i]] = composition[i];
514 }
515 return (
516 pieces["b"].join("") +
517 "/pppppppp/8/8/8/8/PPPPPPPP/" +
518 pieces["w"].join("").toUpperCase() + " w 0"
519 );
520 }
521
522 static get VALUES() {
523 // Experimental...
524 return {
525 p: 1,
526 q: 9,
527 l: 5,
528 s: 5,
529 a: 5,
530 u: 5,
531 i: 12,
532 w: 3,
533 k: 1000
534 };
535 }
536
537 static get SEARCH_DEPTH() {
538 return 2;
539 }
540
541 getNotation(move) {
542 const initialSquare = V.CoordsToSquare(move.start);
543 const finalSquare = V.CoordsToSquare(move.end);
544 if (move.appear.length == 0) {
545 // Archer shooting 'S' or Mutual destruction 'D':
546 return (
547 initialSquare + (move.vanish.length == 1 ? "S" : "D") + finalSquare
548 );
549 }
550 let notation = undefined;
551 const symbol = move.appear[0].p.toUpperCase();
552 if (symbol == 'P')
553 // Pawn: generally ambiguous short notation, so we use full description
554 notation = "P" + initialSquare + finalSquare;
555 else if (['Q', 'K'].includes(symbol))
556 notation = symbol + (move.vanish.length > 1 ? "x" : "") + finalSquare;
557 else {
558 notation = symbol + finalSquare;
559 // Add a capture mark (not describing what is captured...):
560 if (move.vanish.length > 1) notation += "X";
561 }
562 return notation;
563 }
564
565 };