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