Complete FenUtil draft. Untested
[xogo.git] / variants / Chakart / class.js
1 import ChessRules from "/base_rules.js";
2 import GiveawayRules from "/variants/Giveaway/class.js";
3 import {ArrayFun} from "/utils/array.js";
4 import {Random} from "/utils/alea.js";
5 import PiPo from "/utils/PiPo.js";
6 import Move from "/utils/Move.js";
7
8 export default class ChakartRules extends ChessRules {
9
10 static get Options() {
11 return {
12 select: [
13 {
14 label: "Randomness",
15 variable: "randomness",
16 defaut: 2,
17 options: [
18 {label: "Deterministic", value: 0},
19 {label: "Symmetric random", value: 1},
20 {label: "Asymmetric random", value: 2}
21 ]
22 }
23 ],
24 styles: ["cylinder"]
25 };
26 }
27
28 get pawnPromotions() {
29 return ['q', 'r', 'n', 'b', 'k'];
30 }
31
32 get hasCastle() {
33 return false;
34 }
35 get hasEnpassant() {
36 return false;
37 }
38 get hasReserve() {
39 return true;
40 }
41 get hasReserveFen() {
42 return false;
43 }
44
45 static get IMMOBILIZE_CODE() {
46 return {
47 'p': 's',
48 'r': 'u',
49 'n': 'o',
50 'b': 'c',
51 'q': 't',
52 'k': 'l'
53 };
54 }
55
56 static get IMMOBILIZE_DECODE() {
57 return {
58 's': 'p',
59 'u': 'r',
60 'o': 'n',
61 'c': 'b',
62 't': 'q',
63 'l': 'k'
64 };
65 }
66
67 // Fictive color 'a', bomb banana mushroom egg
68 static get BOMB() {
69 return 'w'; //"Wario"
70 }
71 static get BANANA() {
72 return 'd'; //"Donkey"
73 }
74 static get EGG() {
75 return 'e';
76 }
77 static get MUSHROOM() {
78 return 'm';
79 }
80
81 static get EGG_SURPRISE() {
82 return [
83 "kingboo", "bowser", "daisy", "koopa",
84 "luigi", "waluigi", "toadette", "chomp"];
85 }
86
87 canIplay(x, y) {
88 if (
89 this.playerColor != this.turn ||
90 Object.keys(V.IMMOBILIZE_DECODE).includes(this.getPiece(x, y))
91 ) {
92 return false;
93 }
94 return this.egg == "kingboo" || this.getColor(x, y) == this.turn;
95 }
96
97 pieces(color, x, y) {
98 const specials = {
99 'i': {"class": "invisible"}, //queen
100 '?': {"class": "mystery"}, //...initial square
101 'e': {"class": "egg"},
102 'm': {"class": "mushroom"},
103 'd': {"class": "banana"},
104 'w': {"class": "bomb"},
105 'z': {"class": "remote-capture"}
106 };
107 const bowsered = {
108 's': {"class": ["immobilized", "pawn"]},
109 'u': {"class": ["immobilized", "rook"]},
110 'o': {"class": ["immobilized", "knight"]},
111 'c': {"class": ["immobilized", "bishop"]},
112 't': {"class": ["immobilized", "queen"]},
113 'l': {"class": ["immobilized", "king"]}
114 };
115 return Object.assign(
116 {
117 'y': {
118 // Virtual piece for "king remote shell captures"
119 attack: [
120 {
121 steps: [
122 [0, 1], [0, -1], [1, 0], [-1, 0],
123 [1, 1], [1, -1], [-1, 1], [-1, -1]
124 ]
125 }
126 ]
127 }
128 },
129 specials, bowsered, super.pieces(color, x, y)
130 );
131 }
132
133 genRandInitBaseFen() {
134 const options = Object.assign({mode: "suicide"}, this.options);
135 const gr = new GiveawayRules({options: options, genFenOnly: true});
136 let res = gr.genRandInitBaseFen();
137 res.o["flags"] = "1111"; //Peach + Mario flags
138 return res;
139 }
140
141 fen2board(f) {
142 return (
143 f.charCodeAt() <= 90
144 ? "w" + f.toLowerCase()
145 : (['w', 'd', 'e', 'm'].includes(f) ? "a" : "b") + f
146 );
147 }
148
149 setFlags(fenflags) {
150 // King can send shell? Queen can be invisible?
151 this.powerFlags = {
152 w: {k: false, q: false},
153 b: {k: false, q: false}
154 };
155 for (let c of ['w', 'b']) {
156 for (let p of ['k', 'q']) {
157 this.powerFlags[c][p] =
158 fenflags.charAt((c == "w" ? 0 : 2) + (p == 'k' ? 0 : 1)) == "1";
159 }
160 }
161 }
162
163 aggregateFlags() {
164 return this.powerFlags;
165 }
166
167 disaggregateFlags(flags) {
168 this.powerFlags = flags;
169 }
170
171 getFlagsFen() {
172 return ['w', 'b'].map(c => {
173 return ['k', 'q'].map(p => this.powerFlags[c][p] ? "1" : "0").join("");
174 }).join("");
175 }
176
177 setOtherVariables(fenParsed) {
178 super.setOtherVariables(fenParsed);
179 this.egg = null;
180 // Change seed (after FEN generation!!)
181 // so that further calls differ between players:
182 Random.setSeed(Math.floor(19840 * Math.random()));
183 }
184
185 initReserves() {
186 this.reserve = {}; //to be filled later
187 }
188
189 canStepOver(i, j) {
190 return (
191 this.board[i][j] == "" ||
192 ['i', V.EGG, V.MUSHROOM].includes(this.getPiece(i, j))
193 );
194 }
195
196 // For Toadette bonus
197 canDrop([c, p], [i, j]) {
198 return (
199 (
200 this.board[i][j] == "" ||
201 this.getColor(i, j) == 'a' ||
202 this.getPiece(i, j) == 'i'
203 )
204 &&
205 (p != "p" || (c == 'w' && i < this.size.x - 1) || (c == 'b' && i > 0))
206 );
207 }
208
209 getPotentialMovesFrom([x, y]) {
210 let moves = [];
211 const piece = this.getPiece(x, y);
212 if (this.egg == "toadette")
213 moves = this.getDropMovesFrom([x, y]);
214 else if (this.egg == "kingboo") {
215 const color = this.turn;
216 const oppCol = C.GetOppCol(color);
217 // Only allow to swap (non-immobilized!) pieces
218 for (let i=0; i<this.size.x; i++) {
219 for (let j=0; j<this.size.y; j++) {
220 const colIJ = this.getColor(i, j);
221 const pieceIJ = this.getPiece(i, j);
222 if (
223 (i != x || j != y) &&
224 ['w', 'b'].includes(colIJ) &&
225 !Object.keys(V.IMMOBILIZE_DECODE).includes(pieceIJ) &&
226 // Next conditions = no pawn on last rank
227 (
228 piece != 'p' ||
229 (
230 (color != 'w' || i != 0) &&
231 (color != 'b' || i != this.size.x - 1)
232 )
233 )
234 &&
235 (
236 pieceIJ != 'p' ||
237 (
238 (colIJ != 'w' || x != 0) &&
239 (colIJ != 'b' || x != this.size.x - 1)
240 )
241 )
242 ) {
243 let m = this.getBasicMove([x, y], [i, j]);
244 m.appear.push(new PiPo({x: x, y: y, p: pieceIJ, c: colIJ}));
245 m.kingboo = true; //avoid some side effects (bananas/bombs)
246 moves.push(m);
247 }
248 }
249 }
250 }
251 else {
252 // Normal case (including bonus daisy)
253 switch (piece) {
254 case 'p':
255 moves = this.getPawnMovesFrom([x, y]); //apply promotions
256 break;
257 case 'q':
258 moves = this.getQueenMovesFrom([x, y]);
259 break;
260 case 'k':
261 moves = this.getKingMovesFrom([x, y]);
262 break;
263 case 'n':
264 moves = this.getKnightMovesFrom([x, y]);
265 break;
266 case 'b':
267 case 'r':
268 // Explicitely listing types to avoid moving immobilized piece
269 moves = super.getPotentialMovesOf(piece, [x, y]);
270 break;
271 }
272 }
273 return moves;
274 }
275
276 getPawnMovesFrom([x, y]) {
277 const color = this.turn;
278 const oppCol = C.GetOppCol(color);
279 const shiftX = (color == 'w' ? -1 : 1);
280 const firstRank = (color == "w" ? this.size.x - 1 : 0);
281 let moves = [];
282 const frontPiece = this.getPiece(x + shiftX, y);
283 if (
284 this.board[x + shiftX][y] == "" ||
285 this.getColor(x + shiftX, y) == 'a' ||
286 frontPiece == 'i'
287 ) {
288 moves.push(this.getBasicMove([x, y], [x + shiftX, y]));
289 if (
290 [firstRank, firstRank + shiftX].includes(x) &&
291 ![V.BANANA, V.BOMB].includes(frontPiece) &&
292 (
293 this.board[x + 2 * shiftX][y] == "" ||
294 this.getColor(x + 2 * shiftX, y) == 'a' ||
295 this.getPiece(x + 2 * shiftX, y) == 'i'
296 )
297 ) {
298 moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
299 }
300 }
301 for (let shiftY of [-1, 1]) {
302 const nextY = this.getY(y + shiftY);
303 if (
304 nextY >= 0 &&
305 nextY < this.size.y &&
306 this.board[x + shiftX][nextY] != "" &&
307 // Pawns cannot capture invisible queen this way!
308 this.getPiece(x + shiftX, nextY) != 'i' &&
309 ['a', oppCol].includes(this.getColor(x + shiftX, nextY))
310 ) {
311 moves.push(this.getBasicMove([x, y], [x + shiftX, nextY]));
312 }
313 }
314 moves = super.pawnPostProcess(moves, color, oppCol);
315 // Add mushroom on before-last square (+ potential segments)
316 moves.forEach(m => {
317 let [mx, my] = [x, y];
318 if (Math.abs(m.end.x - m.start.x) == 2)
319 mx = (m.start.x + m.end.x) / 2;
320 m.appear.push(new PiPo({x: mx, y: my, c: 'a', p: 'm'}));
321 if (mx != x && this.board[mx][my] != "") {
322 m.vanish.push(new PiPo({
323 x: mx,
324 y: my,
325 c: this.getColor(mx, my),
326 p: this.getPiece(mx, my)
327 }));
328 }
329 if (Math.abs(m.end.y - m.start.y) > 1) {
330 m.segments = [
331 [[x, y], [x, y]],
332 [[m.end.x, m.end.y], [m.end.x, m.end.y]]
333 ];
334 }
335 });
336 return moves;
337 }
338
339 getKnightMovesFrom([x, y]) {
340 // Add egg on initial square:
341 return super.getPotentialMovesOf('n', [x, y]).map(m => {
342 m.appear.push(new PiPo({p: "e", c: "a", x: x, y: y}));
343 return m;
344 });
345 }
346
347 getQueenMovesFrom(sq) {
348 const normalMoves = super.getPotentialMovesOf('q', sq);
349 // If flag allows it, add 'invisible movements'
350 let invisibleMoves = [];
351 if (this.powerFlags[this.turn]['q']) {
352 normalMoves.forEach(m => {
353 if (
354 m.appear.length == 1 &&
355 m.vanish.length == 1 &&
356 // Only simple non-capturing moves:
357 m.vanish[0].c != 'a'
358 ) {
359 let im = JSON.parse(JSON.stringify(m));
360 im.appear[0].p = 'i';
361 im.noAnimate = true;
362 invisibleMoves.push(im);
363 }
364 });
365 }
366 return normalMoves.concat(invisibleMoves);
367 }
368
369 getKingMovesFrom([x, y]) {
370 let moves = super.getPotentialMovesOf('k', [x, y]);
371 // If flag allows it, add 'remote shell captures'
372 if (this.powerFlags[this.turn]['k']) {
373 let shellCaptures = super.getPotentialMovesOf('y', [x, y]);
374 shellCaptures.forEach(sc => {
375 sc.shell = true; //easier play()
376 sc.choice = 'z'; //to display in showChoices()
377 // Fix move (Rifle style):
378 sc.vanish.shift();
379 sc.appear.shift();
380 });
381 Array.prototype.push.apply(moves, shellCaptures);
382 }
383 return moves;
384 }
385
386 play(move) {
387 const color = this.turn;
388 const oppCol = C.GetOppCol(color);
389 this.egg = move.egg;
390 if (move.egg == "toadette") {
391 this.reserve = { w: {}, b: {} };
392 // Randomly select a piece in pawnPromotions
393 if (!move.toadette)
394 move.toadette = Random.sample(this.pawnPromotions);
395 this.reserve[color][move.toadette] = 1;
396 this.re_drawReserve([color]);
397 }
398 else if (Object.keys(this.reserve).length > 0) {
399 this.reserve = {};
400 this.re_drawReserve([color]);
401 }
402 if (move.shell)
403 this.powerFlags[color]['k'] = false;
404 else if (move.appear.length > 0 && move.appear[0].p == 'i') {
405 this.powerFlags[move.appear[0].c]['q'] = false;
406 if (color == this.playerColor) {
407 move.appear.push(
408 new PiPo({x: move.start.x, y: move.start.y, c: color, p: '?'}));
409 }
410 }
411 if (color == this.playerColor) {
412 // Look for an immobilized piece of my color: it can now move
413 for (let i=0; i<8; i++) {
414 for (let j=0; j<8; j++) {
415 if ((i != move.end.x || j != move.end.y) && this.board[i][j] != "") {
416 const piece = this.getPiece(i, j);
417 if (
418 this.getColor(i, j) == color &&
419 Object.keys(V.IMMOBILIZE_DECODE).includes(piece)
420 ) {
421 move.vanish.push(new PiPo({
422 x: i, y: j, c: color, p: piece
423 }));
424 move.appear.push(new PiPo({
425 x: i, y: j, c: color, p: V.IMMOBILIZE_DECODE[piece]
426 }));
427 }
428 }
429 }
430 }
431 // Also make opponent invisible queen visible again, if any
432 for (let i=0; i<8; i++) {
433 for (let j=0; j<8; j++) {
434 if (
435 this.board[i][j] != "" &&
436 this.getColor(i, j) == oppCol
437 ) {
438 const pieceIJ = this.getPiece(i, j);
439 if (
440 pieceIJ == 'i' &&
441 // Ensure that current move doesn't erase invisible queen
442 move.appear.every(a => a.x != i || a.y != j)
443 ) {
444 move.vanish.push(new PiPo({x: i, y: j, c: oppCol, p: 'i'}));
445 move.appear.push(new PiPo({x: i, y: j, c: oppCol, p: 'q'}));
446 }
447 else if (pieceIJ == '?')
448 move.vanish.push(new PiPo({x: i, y: j, c: oppCol, p: '?'}));
449 }
450 }
451 }
452 }
453 this.playOnBoard(move);
454 super.postPlay(move);
455 }
456
457 playVisual(move, r) {
458 super.playVisual(move, r);
459 if (move.egg)
460 this.displayBonus(move);
461 }
462
463 buildMoveStack(move, r) {
464 const color = this.turn;
465 if (
466 move.appear.length > 0 &&
467 move.appear[0].p == 'p' &&
468 (
469 (color == 'w' && move.end.x == 0) ||
470 (color == 'b' && move.end.x == this.size.x - 1)
471 )
472 ) {
473 // "Forgotten" promotion, which occurred after some effect
474 let moves = super.pawnPostProcess([move], color, C.GetOppCol(color));
475 super.showChoices(moves, r);
476 }
477 else
478 super.buildMoveStack(move, r);
479 }
480
481 computeNextMove(move) {
482 if (move.koopa)
483 return null;
484 // Set potential random effects, so that play() is deterministic
485 // from opponent viewpoint:
486 const endPiece = this.getPiece(move.end.x, move.end.y);
487 switch (endPiece) {
488 case V.EGG:
489 move.egg = Random.sample(V.EGG_SURPRISE);
490 move.next = this.getEggEffect(move);
491 break;
492 case V.MUSHROOM:
493 move.next = this.getMushroomEffect(move);
494 break;
495 case V.BANANA:
496 case V.BOMB:
497 move.next = this.getBombBananaEffect(move, endPiece);
498 break;
499 }
500 // NOTE: Chakart has also some side-effects:
501 if (
502 !move.next && move.appear.length > 0 &&
503 !move.kingboo && !move.luigiEffect
504 ) {
505 const movingPiece = move.appear[0].p;
506 if (['b', 'r'].includes(movingPiece)) {
507 // Drop a banana or bomb:
508 const bs =
509 this.getRandomSquare([move.end.x, move.end.y],
510 movingPiece == 'r'
511 ? [[1, 1], [1, -1], [-1, 1], [-1, -1]]
512 : [[1, 0], [-1, 0], [0, 1], [0, -1]],
513 "freeSquare");
514 if (bs) {
515 move.appear.push(
516 new PiPo({
517 x: bs[0],
518 y: bs[1],
519 c: 'a',
520 p: movingPiece == 'r' ? 'd' : 'w'
521 })
522 );
523 if (this.board[bs[0]][bs[1]] != "") {
524 move.vanish.push(
525 new PiPo({
526 x: bs[0],
527 y: bs[1],
528 c: this.getColor(bs[0], bs[1]),
529 p: this.getPiece(bs[0], bs[1])
530 })
531 );
532 }
533 }
534 }
535 }
536 }
537
538 isLastMove(move) {
539 return !move.next && !["daisy", "toadette", "kingboo"].includes(move.egg);
540 }
541
542 // Helper to set and apply banana/bomb effect
543 getRandomSquare([x, y], steps, freeSquare) {
544 let validSteps = steps.filter(s => this.onBoard(x + s[0], y + s[1]));
545 if (freeSquare) {
546 // Square to put banana/bomb cannot be occupied by a piece
547 validSteps = validSteps.filter(s => {
548 return ["", 'a'].includes(this.getColor(x + s[0], y + s[1]))
549 });
550 }
551 if (validSteps.length == 0)
552 return null;
553 const step = validSteps[Random.randInt(validSteps.length)];
554 return [x + step[0], y + step[1]];
555 }
556
557 getEggEffect(move) {
558 const getRandomPiece = (c) => {
559 let bagOfPieces = [];
560 for (let i=0; i<this.size.x; i++) {
561 for (let j=0; j<this.size.y; j++) {
562 const pieceIJ = this.getPiece(i, j);
563 if (
564 this.getColor(i, j) == c && pieceIJ != 'k' &&
565 (
566 // The color will change, so pawns on first rank are ineligible
567 pieceIJ != 'p' ||
568 (c == 'w' && i < this.size.x - 1) || (c == 'b' && i > 0)
569 )
570 ) {
571 bagOfPieces.push([i, j]);
572 }
573 }
574 }
575 if (bagOfPieces.length >= 1)
576 return Random.sample(bagOfPieces);
577 return null;
578 };
579 const color = this.turn;
580 let em = null;
581 switch (move.egg) {
582 case "luigi":
583 case "waluigi":
584 // Change color of friendly or enemy piece, king excepted
585 const oldColor = (move.egg == "waluigi" ? color : C.GetOppCol(color));
586 const newColor = C.GetOppCol(oldColor);
587 const coords = getRandomPiece(oldColor);
588 if (coords) {
589 const piece = this.getPiece(coords[0], coords[1]);
590 em = new Move({
591 appear: [
592 new PiPo({x: coords[0], y: coords[1], c: newColor, p: piece})
593 ],
594 vanish: [
595 new PiPo({x: coords[0], y: coords[1], c: oldColor, p: piece})
596 ]
597 });
598 em.luigiEffect = true; //avoid dropping bomb/banana by mistake
599 }
600 break;
601 case "bowser":
602 em = new Move({
603 appear: [
604 new PiPo({
605 x: move.end.x,
606 y: move.end.y,
607 c: color,
608 p: V.IMMOBILIZE_CODE[move.appear[0].p]
609 })
610 ],
611 vanish: [
612 new PiPo({
613 x: move.end.x,
614 y: move.end.y,
615 c: color,
616 p: move.appear[0].p
617 })
618 ]
619 });
620 break;
621 case "koopa":
622 // Reverse move
623 em = new Move({
624 appear: [
625 new PiPo({
626 x: move.start.x, y: move.start.y, c: color, p: move.appear[0].p
627 })
628 ],
629 vanish: [
630 new PiPo({
631 x: move.end.x, y: move.end.y, c: color, p: move.appear[0].p
632 })
633 ]
634 });
635 if (this.board[move.start.x][move.start.y] != "") {
636 // Pawn or knight let something on init square
637 em.vanish.push(new PiPo({
638 x: move.start.x,
639 y: move.start.y,
640 c: 'a',
641 p: this.getPiece(move.start.x, move.start.y)
642 }));
643 }
644 em.koopa = true; //avoid applying effect
645 break;
646 case "chomp":
647 // Eat piece
648 em = new Move({
649 appear: [],
650 vanish: [
651 new PiPo({
652 x: move.end.x, y: move.end.y, c: color, p: move.appear[0].p
653 })
654 ],
655 end: {x: move.end.x, y: move.end.y}
656 });
657 break;
658 }
659 if (em && move.egg != "koopa")
660 em.noAnimate = true; //static move
661 return em;
662 }
663
664 getMushroomEffect(move) {
665 if (
666 typeof move.start.x == "string" || //drop move (toadette)
667 ['b', 'r', 'q'].includes(move.vanish[0].p) //slider
668 ) {
669 return null;
670 }
671 let step = [move.end.x - move.start.x, move.end.y - move.start.y];
672 if (Math.abs(step[0]) == 2 && Math.abs(step[1]) == 0)
673 // Pawn initial 2-squares move: normalize step
674 step[0] /= 2;
675 const nextSquare = [move.end.x + step[0], move.end.y + step[1]];
676 let nextMove = null;
677 if (
678 this.onBoard(nextSquare[0], nextSquare[1]) &&
679 (
680 this.board[nextSquare[0]][nextSquare[1]] == "" ||
681 this.getColor(nextSquare[0], nextSquare[1]) == 'a'
682 )
683 ) {
684 this.playOnBoard(move); //HACK for getBasicMove()
685 nextMove = this.getBasicMove([move.end.x, move.end.y], nextSquare);
686 this.undoOnBoard(move);
687 }
688 return nextMove;
689 }
690
691 getBombBananaEffect(move, item) {
692 const steps = item == V.BANANA
693 ? [[1, 0], [-1, 0], [0, 1], [0, -1]]
694 : [[1, 1], [1, -1], [-1, 1], [-1, -1]];
695 const nextSquare = this.getRandomSquare([move.end.x, move.end.y], steps);
696 this.playOnBoard(move); //HACK for getBasicMove()
697 const res = this.getBasicMove([move.end.x, move.end.y], nextSquare);
698 this.undoOnBoard(move);
699 return res;
700 }
701
702 displayBonus(move) {
703 super.displayMessage(null, move.egg, "bonus-text", 2000);
704 }
705
706 atLeastOneMove() {
707 return true;
708 }
709
710 filterValid(moves) {
711 return moves;
712 }
713
714 // Kingboo bonus can be animated better:
715 customAnimate(move, segments, cb) {
716 if (!move.kingboo)
717 return 0;
718 super.animateMoving(move.end, move.start, null,
719 segments.reverse().map(s => s.reverse()), cb);
720 return 1;
721 }
722
723 };