Fix Alapo
[xogo.git] / base_rules.js
1 import { Random } from "/utils/alea.js";
2 import { ArrayFun } from "/utils/array.js";
3 import PiPo from "/utils/PiPo.js";
4 import Move from "/utils/Move.js";
5
6 // NOTE: x coords: top to bottom (white perspective); y: left to right
7 // NOTE: ChessRules is aliased as window.C, and variants as window.V
8 export default class ChessRules {
9
10 static get Aliases() {
11 return {'C': ChessRules};
12 }
13
14 /////////////////////////
15 // VARIANT SPECIFICATIONS
16
17 // Some variants have specific options, like the number of pawns in Monster,
18 // or the board size for Pandemonium.
19 // Users can generally select a randomness level from 0 to 2.
20 static get Options() {
21 return {
22 select: [{
23 label: "Randomness",
24 variable: "randomness",
25 defaut: 0,
26 options: [
27 {label: "Deterministic", value: 0},
28 {label: "Symmetric random", value: 1},
29 {label: "Asymmetric random", value: 2}
30 ]
31 }],
32 input: [
33 {
34 label: "Capture king",
35 variable: "taking",
36 type: "checkbox",
37 defaut: false
38 },
39 {
40 label: "Falling pawn",
41 variable: "pawnfall",
42 type: "checkbox",
43 defaut: false
44 }
45 ],
46 // Game modifiers (using "elementary variants"). Default: false
47 styles: [
48 "atomic",
49 "balance", //takes precedence over doublemove & progressive
50 "cannibal",
51 "capture",
52 "crazyhouse",
53 "cylinder", //ok with all
54 "dark",
55 "doublemove",
56 "madrasi",
57 "progressive", //(natural) priority over doublemove
58 "recycle",
59 "rifle",
60 "teleport",
61 "zen"
62 ]
63 };
64 }
65
66 get pawnPromotions() {
67 return ['q', 'r', 'n', 'b'];
68 }
69
70 // Some variants don't have flags:
71 get hasFlags() {
72 return true;
73 }
74 // Or castle
75 get hasCastle() {
76 return this.hasFlags;
77 }
78
79 // En-passant captures allowed?
80 get hasEnpassant() {
81 return true;
82 }
83
84 get hasReserve() {
85 return (
86 !!this.options["crazyhouse"] ||
87 (!!this.options["recycle"] && !this.options["teleport"])
88 );
89 }
90 // Some variants do not store reserve state (Align4, Chakart...)
91 get hasReserveFen() {
92 return this.hasReserve;
93 }
94
95 get noAnimate() {
96 return !!this.options["dark"];
97 }
98
99 // Some variants use click infos:
100 doClick(coords) {
101 if (typeof coords.x != "number")
102 return null; //click on reserves
103 if (
104 this.options["teleport"] && this.subTurnTeleport == 2 &&
105 this.board[coords.x][coords.y] == ""
106 ) {
107 let res = new Move({
108 start: {x: this.captured.x, y: this.captured.y},
109 appear: [
110 new PiPo({
111 x: coords.x,
112 y: coords.y,
113 c: this.captured.c, //this.turn,
114 p: this.captured.p
115 })
116 ],
117 vanish: []
118 });
119 res.drag = {c: this.captured.c, p: this.captured.p};
120 return res;
121 }
122 return null;
123 }
124
125 ////////////////////
126 // COORDINATES UTILS
127
128 // 3a --> {x:3, y:10}
129 static SquareToCoords(sq) {
130 return ArrayFun.toObject(["x", "y"],
131 [0, 1].map(i => parseInt(sq[i], 36)));
132 }
133
134 // {x:11, y:12} --> bc
135 static CoordsToSquare(cd) {
136 return Object.values(cd).map(c => c.toString(36)).join("");
137 }
138
139 coordsToId(cd) {
140 if (typeof cd.x == "number") {
141 return (
142 `${this.containerId}|sq-${cd.x.toString(36)}-${cd.y.toString(36)}`
143 );
144 }
145 // Reserve :
146 return `${this.containerId}|rsq-${cd.x}-${cd.y}`;
147 }
148
149 idToCoords(targetId) {
150 if (!targetId)
151 return null; //outside page, maybe...
152 const idParts = targetId.split('|'); //prefix|sq-2-3 (start at 0 => 3,4)
153 if (
154 idParts.length < 2 ||
155 idParts[0] != this.containerId ||
156 !idParts[1].match(/sq-[0-9a-zA-Z]-[0-9a-zA-Z]/)
157 ) {
158 return null;
159 }
160 const squares = idParts[1].split('-');
161 if (squares[0] == "sq")
162 return {x: parseInt(squares[1], 36), y: parseInt(squares[2], 36)};
163 // squares[0] == "rsq" : reserve, 'c' + 'p' (letters color & piece)
164 return {x: squares[1], y: squares[2]};
165 }
166
167 /////////////
168 // FEN UTILS
169
170 // Turn "wb" into "B" (for FEN)
171 board2fen(b) {
172 return (b[0] == "w" ? b[1].toUpperCase() : b[1]);
173 }
174
175 // Turn "p" into "bp" (for board)
176 fen2board(f) {
177 return (f.charCodeAt(0) <= 90 ? "w" + f.toLowerCase() : "b" + f);
178 }
179
180 // Setup the initial random-or-not (asymmetric-or-not) position
181 genRandInitFen(seed) {
182 let fen, flags = "0707";
183 if (!this.options.randomness)
184 // Deterministic:
185 fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0";
186
187 else {
188 // Randomize
189 Random.setSeed(seed);
190 let pieces = {w: new Array(8), b: new Array(8)};
191 flags = "";
192 // Shuffle pieces on first (and last rank if randomness == 2)
193 for (let c of ["w", "b"]) {
194 if (c == 'b' && this.options.randomness == 1) {
195 pieces['b'] = pieces['w'];
196 flags += flags;
197 break;
198 }
199
200 let positions = ArrayFun.range(8);
201
202 // Get random squares for bishops
203 let randIndex = 2 * Random.randInt(4);
204 const bishop1Pos = positions[randIndex];
205 // The second bishop must be on a square of different color
206 let randIndex_tmp = 2 * Random.randInt(4) + 1;
207 const bishop2Pos = positions[randIndex_tmp];
208 // Remove chosen squares
209 positions.splice(Math.max(randIndex, randIndex_tmp), 1);
210 positions.splice(Math.min(randIndex, randIndex_tmp), 1);
211
212 // Get random squares for knights
213 randIndex = Random.randInt(6);
214 const knight1Pos = positions[randIndex];
215 positions.splice(randIndex, 1);
216 randIndex = Random.randInt(5);
217 const knight2Pos = positions[randIndex];
218 positions.splice(randIndex, 1);
219
220 // Get random square for queen
221 randIndex = Random.randInt(4);
222 const queenPos = positions[randIndex];
223 positions.splice(randIndex, 1);
224
225 // Rooks and king positions are now fixed,
226 // because of the ordering rook-king-rook
227 const rook1Pos = positions[0];
228 const kingPos = positions[1];
229 const rook2Pos = positions[2];
230
231 // Finally put the shuffled pieces in the board array
232 pieces[c][rook1Pos] = "r";
233 pieces[c][knight1Pos] = "n";
234 pieces[c][bishop1Pos] = "b";
235 pieces[c][queenPos] = "q";
236 pieces[c][kingPos] = "k";
237 pieces[c][bishop2Pos] = "b";
238 pieces[c][knight2Pos] = "n";
239 pieces[c][rook2Pos] = "r";
240 flags += rook1Pos.toString() + rook2Pos.toString();
241 }
242 fen = (
243 pieces["b"].join("") +
244 "/pppppppp/8/8/8/8/PPPPPPPP/" +
245 pieces["w"].join("").toUpperCase() +
246 " w 0"
247 );
248 }
249 // Add turn + flags + enpassant (+ reserve)
250 let parts = [];
251 if (this.hasFlags)
252 parts.push(`"flags":"${flags}"`);
253 if (this.hasEnpassant)
254 parts.push('"enpassant":"-"');
255 if (this.hasReserve)
256 parts.push('"reserve":"000000000000"');
257 if (this.options["crazyhouse"])
258 parts.push('"ispawn":"-"');
259 if (parts.length >= 1)
260 fen += " {" + parts.join(",") + "}";
261 return fen;
262 }
263
264 // "Parse" FEN: just return untransformed string data
265 parseFen(fen) {
266 const fenParts = fen.split(" ");
267 let res = {
268 position: fenParts[0],
269 turn: fenParts[1],
270 movesCount: fenParts[2]
271 };
272 if (fenParts.length > 3)
273 res = Object.assign(res, JSON.parse(fenParts[3]));
274 return res;
275 }
276
277 // Return current fen (game state)
278 getFen() {
279 let fen = (
280 this.getPosition() + " " +
281 this.getTurnFen() + " " +
282 this.movesCount
283 );
284 let parts = [];
285 if (this.hasFlags)
286 parts.push(`"flags":"${this.getFlagsFen()}"`);
287 if (this.hasEnpassant)
288 parts.push(`"enpassant":"${this.getEnpassantFen()}"`);
289 if (this.hasReserveFen)
290 parts.push(`"reserve":"${this.getReserveFen()}"`);
291 if (this.options["crazyhouse"])
292 parts.push(`"ispawn":"${this.getIspawnFen()}"`);
293 if (parts.length >= 1)
294 fen += " {" + parts.join(",") + "}";
295 return fen;
296 }
297
298 static FenEmptySquares(count) {
299 // if more than 9 consecutive free spaces, break the integer,
300 // otherwise FEN parsing will fail.
301 if (count <= 9)
302 return count;
303 // Most boards of size < 18:
304 if (count <= 18)
305 return "9" + (count - 9);
306 // Except Gomoku:
307 return "99" + (count - 18);
308 }
309
310 // Position part of the FEN string
311 getPosition() {
312 let position = "";
313 for (let i = 0; i < this.size.y; i++) {
314 let emptyCount = 0;
315 for (let j = 0; j < this.size.x; j++) {
316 if (this.board[i][j] == "")
317 emptyCount++;
318 else {
319 if (emptyCount > 0) {
320 // Add empty squares in-between
321 position += C.FenEmptySquares(emptyCount);
322 emptyCount = 0;
323 }
324 position += this.board2fen(this.board[i][j]);
325 }
326 }
327 if (emptyCount > 0)
328 // "Flush remainder"
329 position += C.FenEmptySquares(emptyCount);
330 if (i < this.size.y - 1)
331 position += "/"; //separate rows
332 }
333 return position;
334 }
335
336 getTurnFen() {
337 return this.turn;
338 }
339
340 // Flags part of the FEN string
341 getFlagsFen() {
342 return ["w", "b"].map(c => {
343 return this.castleFlags[c].map(x => x.toString(36)).join("");
344 }).join("");
345 }
346
347 // Enpassant part of the FEN string
348 getEnpassantFen() {
349 if (!this.epSquare)
350 return "-"; //no en-passant
351 return C.CoordsToSquare(this.epSquare);
352 }
353
354 getReserveFen() {
355 return (
356 ["w","b"].map(c => Object.values(this.reserve[c]).join("")).join("")
357 );
358 }
359
360 getIspawnFen() {
361 const squares = Object.keys(this.ispawn);
362 if (squares.length == 0)
363 return "-";
364 return squares.join(",");
365 }
366
367 // Set flags from fen (castle: white a,h then black a,h)
368 setFlags(fenflags) {
369 this.castleFlags = {
370 w: [0, 1].map(i => parseInt(fenflags.charAt(i), 36)),
371 b: [2, 3].map(i => parseInt(fenflags.charAt(i), 36))
372 };
373 }
374
375 //////////////////
376 // INITIALIZATION
377
378 constructor(o) {
379 this.options = o.options;
380 // Fill missing options (always the case if random challenge)
381 (V.Options.select || []).concat(V.Options.input || []).forEach(opt => {
382 if (this.options[opt.variable] === undefined)
383 this.options[opt.variable] = opt.defaut;
384 });
385 if (o.genFenOnly)
386 // This object will be used only for initial FEN generation
387 return;
388 this.playerColor = o.color;
389 this.afterPlay = o.afterPlay; //trigger some actions after playing a move
390
391 // Fen string fully describes the game state
392 if (!o.fen)
393 o.fen = this.genRandInitFen(o.seed);
394 const fenParsed = this.parseFen(o.fen);
395 this.board = this.getBoard(fenParsed.position);
396 this.turn = fenParsed.turn;
397 this.movesCount = parseInt(fenParsed.movesCount, 10);
398 this.setOtherVariables(fenParsed);
399
400 // Graphical (can use variables defined above)
401 this.containerId = o.element;
402 this.graphicalInit();
403 }
404
405 // Turn position fen into double array ["wb","wp","bk",...]
406 getBoard(position) {
407 const rows = position.split("/");
408 let board = ArrayFun.init(this.size.x, this.size.y, "");
409 for (let i = 0; i < rows.length; i++) {
410 let j = 0;
411 for (let indexInRow = 0; indexInRow < rows[i].length; indexInRow++) {
412 const character = rows[i][indexInRow];
413 const num = parseInt(character, 10);
414 // If num is a number, just shift j:
415 if (!isNaN(num))
416 j += num;
417 // Else: something at position i,j
418 else
419 board[i][j++] = this.fen2board(character);
420 }
421 }
422 return board;
423 }
424
425 // Some additional variables from FEN (variant dependant)
426 setOtherVariables(fenParsed) {
427 // Set flags and enpassant:
428 if (this.hasFlags)
429 this.setFlags(fenParsed.flags);
430 if (this.hasEnpassant)
431 this.epSquare = this.getEpSquare(fenParsed.enpassant);
432 if (this.hasReserve)
433 this.initReserves(fenParsed.reserve);
434 if (this.options["crazyhouse"])
435 this.initIspawn(fenParsed.ispawn);
436 this.subTurn = 1; //may be unused
437 if (this.options["teleport"]) {
438 this.subTurnTeleport = 1;
439 this.captured = null;
440 }
441 if (this.options["dark"]) {
442 // Setup enlightened: squares reachable by player side
443 this.enlightened = ArrayFun.init(this.size.x, this.size.y, false);
444 this.updateEnlightened();
445 }
446 }
447
448 updateEnlightened() {
449 this.oldEnlightened = this.enlightened;
450 this.enlightened = ArrayFun.init(this.size.x, this.size.y, false);
451 // Add pieces positions + all squares reachable by moves (includes Zen):
452 for (let x=0; x<this.size.x; x++) {
453 for (let y=0; y<this.size.y; y++) {
454 if (this.board[x][y] != "" && this.getColor(x, y) == this.playerColor)
455 {
456 this.enlightened[x][y] = true;
457 this.getPotentialMovesFrom([x, y]).forEach(m => {
458 this.enlightened[m.end.x][m.end.y] = true;
459 });
460 }
461 }
462 }
463 if (this.epSquare)
464 this.enlightEnpassant();
465 }
466
467 // Include square of the en-passant capturing square:
468 enlightEnpassant() {
469 // NOTE: shortcut, pawn has only one attack type, doesn't depend on square
470 const steps = this.pieces(this.playerColor)["p"].attack[0].steps;
471 for (let step of steps) {
472 const x = this.epSquare.x - step[0],
473 y = this.getY(this.epSquare.y - step[1]);
474 if (
475 this.onBoard(x, y) &&
476 this.getColor(x, y) == this.playerColor &&
477 this.getPieceType(x, y) == "p"
478 ) {
479 this.enlightened[x][this.epSquare.y] = true;
480 break;
481 }
482 }
483 }
484
485 // ordering as in pieces() p,r,n,b,q,k (+ count in base 30 if needed)
486 initReserves(reserveStr) {
487 const counts = reserveStr.split("").map(c => parseInt(c, 30));
488 this.reserve = { w: {}, b: {} };
489 const pieceName = ['p', 'r', 'n', 'b', 'q', 'k'];
490 const L = pieceName.length;
491 for (let i of ArrayFun.range(2 * L)) {
492 if (i < L)
493 this.reserve['w'][pieceName[i]] = counts[i];
494 else
495 this.reserve['b'][pieceName[i-L]] = counts[i];
496 }
497 }
498
499 initIspawn(ispawnStr) {
500 if (ispawnStr != "-")
501 this.ispawn = ArrayFun.toObject(ispawnStr.split(","), true);
502 else
503 this.ispawn = {};
504 }
505
506 getNbReservePieces(color) {
507 return (
508 Object.values(this.reserve[color]).reduce(
509 (oldV,newV) => oldV + (newV > 0 ? 1 : 0), 0)
510 );
511 }
512
513 getRankInReserve(c, p) {
514 const pieces = Object.keys(this.pieces());
515 const lastIndex = pieces.findIndex(pp => pp == p)
516 let toTest = pieces.slice(0, lastIndex);
517 return toTest.reduce(
518 (oldV,newV) => oldV + (this.reserve[c][newV] > 0 ? 1 : 0), 0);
519 }
520
521 //////////////
522 // VISUAL PART
523
524 getPieceWidth(rwidth) {
525 return (rwidth / this.size.y);
526 }
527
528 getReserveSquareSize(rwidth, nbR) {
529 const sqSize = this.getPieceWidth(rwidth);
530 return Math.min(sqSize, rwidth / nbR);
531 }
532
533 getReserveNumId(color, piece) {
534 return `${this.containerId}|rnum-${color}${piece}`;
535 }
536
537 static AddClass_es(piece, class_es) {
538 if (!Array.isArray(class_es))
539 class_es = [class_es];
540 class_es.forEach(cl => {
541 piece.classList.add(cl);
542 });
543 }
544
545 static RemoveClass_es(piece, class_es) {
546 if (!Array.isArray(class_es))
547 class_es = [class_es];
548 class_es.forEach(cl => {
549 piece.classList.remove(cl);
550 });
551 }
552
553 graphicalInit() {
554 // NOTE: not window.onresize = this.re_drawBoardElts because scope (this)
555 window.onresize = () => this.re_drawBoardElements();
556 this.re_drawBoardElements();
557 this.initMouseEvents();
558 const chessboard =
559 document.getElementById(this.containerId).querySelector(".chessboard");
560 }
561
562 re_drawBoardElements() {
563 const board = this.getSvgChessboard();
564 const oppCol = C.GetOppCol(this.playerColor);
565 let chessboard =
566 document.getElementById(this.containerId).querySelector(".chessboard");
567 chessboard.innerHTML = "";
568 chessboard.insertAdjacentHTML('beforeend', board);
569 // Compare window ratio width / height to aspectRatio:
570 const windowRatio = window.innerWidth / window.innerHeight;
571 let cbWidth, cbHeight;
572 const vRatio = this.size.ratio || 1;
573 if (windowRatio <= vRatio) {
574 // Limiting dimension is width:
575 cbWidth = Math.min(window.innerWidth, 767);
576 cbHeight = cbWidth / vRatio;
577 }
578 else {
579 // Limiting dimension is height:
580 cbHeight = Math.min(window.innerHeight, 767);
581 cbWidth = cbHeight * vRatio;
582 }
583 if (this.hasReserve) {
584 const sqSize = cbWidth / this.size.y;
585 // NOTE: allocate space for reserves (up/down) even if they are empty
586 // Cannot use getReserveSquareSize() here, but sqSize is an upper bound.
587 if ((window.innerHeight - cbHeight) / 2 < sqSize + 5) {
588 cbHeight = window.innerHeight - 2 * (sqSize + 5);
589 cbWidth = cbHeight * vRatio;
590 }
591 }
592 chessboard.style.width = cbWidth + "px";
593 chessboard.style.height = cbHeight + "px";
594 // Center chessboard:
595 const spaceLeft = (window.innerWidth - cbWidth) / 2,
596 spaceTop = (window.innerHeight - cbHeight) / 2;
597 chessboard.style.left = spaceLeft + "px";
598 chessboard.style.top = spaceTop + "px";
599 // Give sizes instead of recomputing them,
600 // because chessboard might not be drawn yet.
601 this.setupPieces({
602 width: cbWidth,
603 height: cbHeight,
604 x: spaceLeft,
605 y: spaceTop
606 });
607 }
608
609 // Get SVG board (background, no pieces)
610 getSvgChessboard() {
611 const flipped = (this.playerColor == 'b');
612 let board = `
613 <svg
614 viewBox="0 0 ${10*this.size.y} ${10*this.size.x}"
615 class="chessboard_SVG">`;
616 for (let i=0; i < this.size.x; i++) {
617 for (let j=0; j < this.size.y; j++) {
618 const ii = (flipped ? this.size.x - 1 - i : i);
619 const jj = (flipped ? this.size.y - 1 - j : j);
620 let classes = this.getSquareColorClass(ii, jj);
621 if (this.enlightened && !this.enlightened[ii][jj])
622 classes += " in-shadow";
623 // NOTE: x / y reversed because coordinates system is reversed.
624 board += `
625 <rect
626 class="${classes}"
627 id="${this.coordsToId({x: ii, y: jj})}"
628 width="10"
629 height="10"
630 x="${10*j}"
631 y="${10*i}"
632 />`;
633 }
634 }
635 board += "</svg>";
636 return board;
637 }
638
639 // Generally light square bottom-right
640 getSquareColorClass(x, y) {
641 return ((x+y) % 2 == 0 ? "light-square": "dark-square");
642 }
643
644 setupPieces(r) {
645 if (this.g_pieces) {
646 // Refreshing: delete old pieces first
647 for (let i=0; i<this.size.x; i++) {
648 for (let j=0; j<this.size.y; j++) {
649 if (this.g_pieces[i][j]) {
650 this.g_pieces[i][j].remove();
651 this.g_pieces[i][j] = null;
652 }
653 }
654 }
655 }
656 else
657 this.g_pieces = ArrayFun.init(this.size.x, this.size.y, null);
658 let chessboard =
659 document.getElementById(this.containerId).querySelector(".chessboard");
660 if (!r)
661 r = chessboard.getBoundingClientRect();
662 const pieceWidth = this.getPieceWidth(r.width);
663 for (let i=0; i < this.size.x; i++) {
664 for (let j=0; j < this.size.y; j++) {
665 if (this.board[i][j] != "") {
666 const color = this.getColor(i, j);
667 const piece = this.getPiece(i, j);
668 this.g_pieces[i][j] = document.createElement("piece");
669 C.AddClass_es(this.g_pieces[i][j],
670 this.pieces(color, i, j)[piece]["class"]);
671 this.g_pieces[i][j].classList.add(C.GetColorClass(color));
672 this.g_pieces[i][j].style.width = pieceWidth + "px";
673 this.g_pieces[i][j].style.height = pieceWidth + "px";
674 let [ip, jp] = this.getPixelPosition(i, j, r);
675 // Translate coordinates to use chessboard as reference:
676 this.g_pieces[i][j].style.transform =
677 `translate(${ip - r.x}px,${jp - r.y}px)`;
678 if (this.enlightened && !this.enlightened[i][j])
679 this.g_pieces[i][j].classList.add("hidden");
680 chessboard.appendChild(this.g_pieces[i][j]);
681 }
682 }
683 }
684 if (this.hasReserve)
685 this.re_drawReserve(['w', 'b'], r);
686 }
687
688 // NOTE: assume this.reserve != null
689 re_drawReserve(colors, r) {
690 if (this.r_pieces) {
691 // Remove (old) reserve pieces
692 for (let c of colors) {
693 Object.keys(this.r_pieces[c]).forEach(p => {
694 this.r_pieces[c][p].remove();
695 delete this.r_pieces[c][p];
696 const numId = this.getReserveNumId(c, p);
697 document.getElementById(numId).remove();
698 });
699 }
700 }
701 else
702 this.r_pieces = { w: {}, b: {} };
703 let container = document.getElementById(this.containerId);
704 if (!r)
705 r = container.querySelector(".chessboard").getBoundingClientRect();
706 for (let c of colors) {
707 let reservesDiv = document.getElementById("reserves_" + c);
708 if (reservesDiv)
709 reservesDiv.remove();
710 if (!this.reserve[c])
711 continue;
712 const nbR = this.getNbReservePieces(c);
713 if (nbR == 0)
714 continue;
715 const sqResSize = this.getReserveSquareSize(r.width, nbR);
716 let ridx = 0;
717 const vShift = (c == this.playerColor ? r.height + 5 : -sqResSize - 5);
718 const [i0, j0] = [r.x, r.y + vShift];
719 let rcontainer = document.createElement("div");
720 rcontainer.id = "reserves_" + c;
721 rcontainer.classList.add("reserves");
722 rcontainer.style.left = i0 + "px";
723 rcontainer.style.top = j0 + "px";
724 // NOTE: +1 fix display bug on Firefox at least
725 rcontainer.style.width = (nbR * sqResSize + 1) + "px";
726 rcontainer.style.height = sqResSize + "px";
727 container.appendChild(rcontainer);
728 for (let p of Object.keys(this.reserve[c])) {
729 if (this.reserve[c][p] == 0)
730 continue;
731 let r_cell = document.createElement("div");
732 r_cell.id = this.coordsToId({x: c, y: p});
733 r_cell.classList.add("reserve-cell");
734 r_cell.style.width = sqResSize + "px";
735 r_cell.style.height = sqResSize + "px";
736 rcontainer.appendChild(r_cell);
737 let piece = document.createElement("piece");
738 C.AddClass_es(piece, this.pieces(c, c, p)[p]["class"]);
739 piece.classList.add(C.GetColorClass(c));
740 piece.style.width = "100%";
741 piece.style.height = "100%";
742 this.r_pieces[c][p] = piece;
743 r_cell.appendChild(piece);
744 let number = document.createElement("div");
745 number.textContent = this.reserve[c][p];
746 number.classList.add("reserve-num");
747 number.id = this.getReserveNumId(c, p);
748 const fontSize = "1.3em";
749 number.style.fontSize = fontSize;
750 number.style.fontSize = fontSize;
751 r_cell.appendChild(number);
752 ridx++;
753 }
754 }
755 }
756
757 updateReserve(color, piece, count) {
758 if (this.options["cannibal"] && C.CannibalKings[piece])
759 piece = "k"; //capturing cannibal king: back to king form
760 const oldCount = this.reserve[color][piece];
761 this.reserve[color][piece] = count;
762 // Redrawing is much easier if count==0
763 if ([oldCount, count].includes(0))
764 this.re_drawReserve([color]);
765 else {
766 const numId = this.getReserveNumId(color, piece);
767 document.getElementById(numId).textContent = count;
768 }
769 }
770
771 // Apply diff this.enlightened --> oldEnlightened on board
772 graphUpdateEnlightened() {
773 let chessboard =
774 document.getElementById(this.containerId).querySelector(".chessboard");
775 const r = chessboard.getBoundingClientRect();
776 const pieceWidth = this.getPieceWidth(r.width);
777 for (let x=0; x<this.size.x; x++) {
778 for (let y=0; y<this.size.y; y++) {
779 if (!this.enlightened[x][y] && this.oldEnlightened[x][y]) {
780 let elt = document.getElementById(this.coordsToId({x: x, y: y}));
781 elt.classList.add("in-shadow");
782 if (this.g_pieces[x][y])
783 this.g_pieces[x][y].classList.add("hidden");
784 }
785 else if (this.enlightened[x][y] && !this.oldEnlightened[x][y]) {
786 let elt = document.getElementById(this.coordsToId({x: x, y: y}));
787 elt.classList.remove("in-shadow");
788 if (this.g_pieces[x][y])
789 this.g_pieces[x][y].classList.remove("hidden");
790 }
791 }
792 }
793 }
794
795 // Resize board: no need to destroy/recreate pieces
796 rescale(mode) {
797 let chessboard =
798 document.getElementById(this.containerId).querySelector(".chessboard");
799 const r = chessboard.getBoundingClientRect();
800 const multFact = (mode == "up" ? 1.05 : 0.95);
801 let [newWidth, newHeight] = [multFact * r.width, multFact * r.height];
802 // Stay in window:
803 const vRatio = this.size.ratio || 1;
804 if (newWidth > window.innerWidth) {
805 newWidth = window.innerWidth;
806 newHeight = newWidth / vRatio;
807 }
808 if (newHeight > window.innerHeight) {
809 newHeight = window.innerHeight;
810 newWidth = newHeight * vRatio;
811 }
812 chessboard.style.width = newWidth + "px";
813 chessboard.style.height = newHeight + "px";
814 const newX = (window.innerWidth - newWidth) / 2;
815 chessboard.style.left = newX + "px";
816 const newY = (window.innerHeight - newHeight) / 2;
817 chessboard.style.top = newY + "px";
818 const newR = {x: newX, y: newY, width: newWidth, height: newHeight};
819 const pieceWidth = this.getPieceWidth(newWidth);
820 // NOTE: next "if" for variants which use squares filling
821 // instead of "physical", moving pieces
822 if (this.g_pieces) {
823 for (let i=0; i < this.size.x; i++) {
824 for (let j=0; j < this.size.y; j++) {
825 if (this.g_pieces[i][j]) {
826 // NOTE: could also use CSS transform "scale"
827 this.g_pieces[i][j].style.width = pieceWidth + "px";
828 this.g_pieces[i][j].style.height = pieceWidth + "px";
829 const [ip, jp] = this.getPixelPosition(i, j, newR);
830 // Translate coordinates to use chessboard as reference:
831 this.g_pieces[i][j].style.transform =
832 `translate(${ip - newX}px,${jp - newY}px)`;
833 }
834 }
835 }
836 }
837 if (this.hasReserve)
838 this.rescaleReserve(newR);
839 }
840
841 rescaleReserve(r) {
842 for (let c of ['w','b']) {
843 if (!this.reserve[c])
844 continue;
845 const nbR = this.getNbReservePieces(c);
846 if (nbR == 0)
847 continue;
848 // Resize container first
849 const sqResSize = this.getReserveSquareSize(r.width, nbR);
850 const vShift = (c == this.playerColor ? r.height + 5 : -sqResSize - 5);
851 const [i0, j0] = [r.x, r.y + vShift];
852 let rcontainer = document.getElementById("reserves_" + c);
853 rcontainer.style.left = i0 + "px";
854 rcontainer.style.top = j0 + "px";
855 rcontainer.style.width = (nbR * sqResSize + 1) + "px";
856 rcontainer.style.height = sqResSize + "px";
857 // And then reserve cells:
858 const rpieceWidth = this.getReserveSquareSize(r.width, nbR);
859 Object.keys(this.reserve[c]).forEach(p => {
860 if (this.reserve[c][p] == 0)
861 return;
862 let r_cell = document.getElementById(this.coordsToId({x: c, y: p}));
863 r_cell.style.width = sqResSize + "px";
864 r_cell.style.height = sqResSize + "px";
865 });
866 }
867 }
868
869 // Return the absolute pixel coordinates given current position.
870 // Our coordinate system differs from CSS one (x <--> y).
871 // We return here the CSS coordinates (more useful).
872 getPixelPosition(i, j, r) {
873 if (i < 0 || j < 0)
874 return [0, 0]; //piece vanishes
875 let x, y;
876 if (typeof i == "string") {
877 // Reserves: need to know the rank of piece
878 const nbR = this.getNbReservePieces(i);
879 const rsqSize = this.getReserveSquareSize(r.width, nbR);
880 x = this.getRankInReserve(i, j) * rsqSize;
881 y = (this.playerColor == i ? y = r.height + 5 : - 5 - rsqSize);
882 }
883 else {
884 const sqSize = r.width / this.size.y;
885 const flipped = (this.playerColor == 'b');
886 x = (flipped ? this.size.y - 1 - j : j) * sqSize;
887 y = (flipped ? this.size.x - 1 - i : i) * sqSize;
888 }
889 return [r.x + x, r.y + y];
890 }
891
892 initMouseEvents() {
893 let container = document.getElementById(this.containerId);
894 let chessboard = container.querySelector(".chessboard");
895
896 const getOffset = e => {
897 if (e.clientX)
898 // Mouse
899 return {x: e.clientX, y: e.clientY};
900 let touchLocation = null;
901 if (e.targetTouches && e.targetTouches.length >= 1)
902 // Touch screen, dragstart
903 touchLocation = e.targetTouches[0];
904 else if (e.changedTouches && e.changedTouches.length >= 1)
905 // Touch screen, dragend
906 touchLocation = e.changedTouches[0];
907 if (touchLocation)
908 return {x: touchLocation.clientX, y: touchLocation.clientY};
909 return {x: 0, y: 0}; //shouldn't reach here =)
910 }
911
912 const centerOnCursor = (piece, e) => {
913 const centerShift = this.getPieceWidth(r.width) / 2;
914 const offset = getOffset(e);
915 piece.style.left = (offset.x - centerShift) + "px";
916 piece.style.top = (offset.y - centerShift) + "px";
917 }
918
919 let start = null,
920 r = null,
921 startPiece, curPiece = null,
922 pieceWidth;
923 const mousedown = (e) => {
924 // Disable zoom on smartphones:
925 if (e.touches && e.touches.length > 1)
926 e.preventDefault();
927 r = chessboard.getBoundingClientRect();
928 pieceWidth = this.getPieceWidth(r.width);
929 const cd = this.idToCoords(e.target.id);
930 if (cd) {
931 const move = this.doClick(cd);
932 if (move)
933 this.playPlusVisual(move);
934 else {
935 const [x, y] = Object.values(cd);
936 if (typeof x != "number")
937 startPiece = this.r_pieces[x][y];
938 else
939 startPiece = this.g_pieces[x][y];
940 if (startPiece && this.canIplay(x, y)) {
941 e.preventDefault();
942 start = cd;
943 curPiece = startPiece.cloneNode();
944 curPiece.style.transform = "none";
945 curPiece.style.zIndex = 5;
946 curPiece.style.width = pieceWidth + "px";
947 curPiece.style.height = pieceWidth + "px";
948 centerOnCursor(curPiece, e);
949 container.appendChild(curPiece);
950 startPiece.style.opacity = "0.4";
951 chessboard.style.cursor = "none";
952 }
953 }
954 }
955 };
956
957 const mousemove = (e) => {
958 if (start) {
959 e.preventDefault();
960 centerOnCursor(curPiece, e);
961 }
962 else if (e.changedTouches && e.changedTouches.length >= 1)
963 // Attempt to prevent horizontal swipe...
964 e.preventDefault();
965 };
966
967 const mouseup = (e) => {
968 if (!start)
969 return;
970 const [x, y] = [start.x, start.y];
971 start = null;
972 e.preventDefault();
973 chessboard.style.cursor = "pointer";
974 startPiece.style.opacity = "1";
975 const offset = getOffset(e);
976 const landingElt = document.elementFromPoint(offset.x, offset.y);
977 const cd =
978 (landingElt ? this.idToCoords(landingElt.id) : undefined);
979 if (cd) {
980 // NOTE: clearly suboptimal, but much easier, and not a big deal.
981 const potentialMoves = this.getPotentialMovesFrom([x, y])
982 .filter(m => m.end.x == cd.x && m.end.y == cd.y);
983 const moves = this.filterValid(potentialMoves);
984 if (moves.length >= 2)
985 this.showChoices(moves, r);
986 else if (moves.length == 1)
987 this.playPlusVisual(moves[0], r);
988 }
989 curPiece.remove();
990 };
991
992 if ('onmousedown' in window) {
993 document.addEventListener("mousedown", mousedown);
994 document.addEventListener("mousemove", mousemove);
995 document.addEventListener("mouseup", mouseup);
996 document.addEventListener("wheel",
997 (e) => this.rescale(e.deltaY < 0 ? "up" : "down"));
998 }
999 if ('ontouchstart' in window) {
1000 // https://stackoverflow.com/a/42509310/12660887
1001 document.addEventListener("touchstart", mousedown, {passive: false});
1002 document.addEventListener("touchmove", mousemove, {passive: false});
1003 document.addEventListener("touchend", mouseup, {passive: false});
1004 }
1005 // TODO: onpointerdown/move/up ? See reveal.js /controllers/touch.js
1006 }
1007
1008 showChoices(moves, r) {
1009 let container = document.getElementById(this.containerId);
1010 let chessboard = container.querySelector(".chessboard");
1011 let choices = document.createElement("div");
1012 choices.id = "choices";
1013 if (!r)
1014 r = chessboard.getBoundingClientRect();
1015 choices.style.width = r.width + "px";
1016 choices.style.height = r.height + "px";
1017 choices.style.left = r.x + "px";
1018 choices.style.top = r.y + "px";
1019 chessboard.style.opacity = "0.5";
1020 container.appendChild(choices);
1021 const squareWidth = r.width / this.size.y;
1022 const firstUpLeft = (r.width - (moves.length * squareWidth)) / 2;
1023 const firstUpTop = (r.height - squareWidth) / 2;
1024 const color = moves[0].appear[0].c;
1025 const callback = (m) => {
1026 chessboard.style.opacity = "1";
1027 container.removeChild(choices);
1028 this.playPlusVisual(m, r);
1029 }
1030 for (let i=0; i < moves.length; i++) {
1031 let choice = document.createElement("div");
1032 choice.classList.add("choice");
1033 choice.style.width = squareWidth + "px";
1034 choice.style.height = squareWidth + "px";
1035 choice.style.left = (firstUpLeft + i * squareWidth) + "px";
1036 choice.style.top = firstUpTop + "px";
1037 choice.style.backgroundColor = "lightyellow";
1038 choice.onclick = () => callback(moves[i]);
1039 const piece = document.createElement("piece");
1040 const cdisp = moves[i].choice || moves[i].appear[0].p;
1041 C.AddClass_es(piece,
1042 this.pieces(color, moves[i].end.x, moves[i].end.y)[cdisp]["class"]);
1043 piece.classList.add(C.GetColorClass(color));
1044 piece.style.width = "100%";
1045 piece.style.height = "100%";
1046 choice.appendChild(piece);
1047 choices.appendChild(choice);
1048 }
1049 }
1050
1051 //////////////
1052 // BASIC UTILS
1053
1054 get size() {
1055 return {
1056 x: 8,
1057 y: 8,
1058 ratio: 1 //for rectangular board = y / x (optional, 1 = default)
1059 };
1060 }
1061
1062 // Color of thing on square (i,j). 'undefined' if square is empty
1063 getColor(i, j) {
1064 if (typeof i == "string")
1065 return i; //reserves
1066 return this.board[i][j].charAt(0);
1067 }
1068
1069 static GetColorClass(c) {
1070 if (c == 'w')
1071 return "white";
1072 if (c == 'b')
1073 return "black";
1074 return "other-color"; //unidentified color
1075 }
1076
1077 // Assume square i,j isn't empty
1078 getPiece(i, j) {
1079 if (typeof j == "string")
1080 return j; //reserves
1081 return this.board[i][j].charAt(1);
1082 }
1083
1084 // Piece type on square (i,j)
1085 getPieceType(i, j) {
1086 const p = this.getPiece(i, j);
1087 return C.CannibalKings[p] || p; //a cannibal king move as...
1088 }
1089
1090 // Get opponent color
1091 static GetOppCol(color) {
1092 return (color == "w" ? "b" : "w");
1093 }
1094
1095 // Can thing on square1 capture (no return) thing on square2?
1096 canTake([x1, y1], [x2, y2]) {
1097 return (this.getColor(x1, y1) !== this.getColor(x2, y2));
1098 }
1099
1100 // Is (x,y) on the chessboard?
1101 onBoard(x, y) {
1102 return (x >= 0 && x < this.size.x &&
1103 y >= 0 && y < this.size.y);
1104 }
1105
1106 // Am I allowed to move thing at square x,y ?
1107 canIplay(x, y) {
1108 return (this.playerColor == this.turn && this.getColor(x, y) == this.turn);
1109 }
1110
1111 ////////////////////////
1112 // PIECES SPECIFICATIONS
1113
1114 pieces(color, x, y) {
1115 const pawnShift = (color == "w" ? -1 : 1);
1116 // NOTE: jump 2 squares from first rank (pawns can be here sometimes)
1117 const initRank = ((color == 'w' && x >= 6) || (color == 'b' && x <= 1));
1118 return {
1119 'p': {
1120 "class": "pawn",
1121 moves: [
1122 {
1123 steps: [[pawnShift, 0]],
1124 range: (initRank ? 2 : 1)
1125 }
1126 ],
1127 attack: [
1128 {
1129 steps: [[pawnShift, 1], [pawnShift, -1]],
1130 range: 1
1131 }
1132 ]
1133 },
1134 // rook
1135 'r': {
1136 "class": "rook",
1137 moves: [
1138 {steps: [[0, 1], [0, -1], [1, 0], [-1, 0]]}
1139 ]
1140 },
1141 // knight
1142 'n': {
1143 "class": "knight",
1144 moves: [
1145 {
1146 steps: [
1147 [1, 2], [1, -2], [-1, 2], [-1, -2],
1148 [2, 1], [-2, 1], [2, -1], [-2, -1]
1149 ],
1150 range: 1
1151 }
1152 ]
1153 },
1154 // bishop
1155 'b': {
1156 "class": "bishop",
1157 moves: [
1158 {steps: [[1, 1], [1, -1], [-1, 1], [-1, -1]]}
1159 ]
1160 },
1161 // queen
1162 'q': {
1163 "class": "queen",
1164 moves: [
1165 {
1166 steps: [
1167 [0, 1], [0, -1], [1, 0], [-1, 0],
1168 [1, 1], [1, -1], [-1, 1], [-1, -1]
1169 ]
1170 }
1171 ]
1172 },
1173 // king
1174 'k': {
1175 "class": "king",
1176 moves: [
1177 {
1178 steps: [
1179 [0, 1], [0, -1], [1, 0], [-1, 0],
1180 [1, 1], [1, -1], [-1, 1], [-1, -1]
1181 ],
1182 range: 1
1183 }
1184 ]
1185 },
1186 // Cannibal kings:
1187 '!': {"class": "king-pawn", moveas: "p"},
1188 '#': {"class": "king-rook", moveas: "r"},
1189 '$': {"class": "king-knight", moveas: "n"},
1190 '%': {"class": "king-bishop", moveas: "b"},
1191 '*': {"class": "king-queen", moveas: "q"}
1192 };
1193 }
1194
1195 ////////////////////
1196 // MOVES GENERATION
1197
1198 // For Cylinder: get Y coordinate
1199 getY(y) {
1200 if (!this.options["cylinder"])
1201 return y;
1202 let res = y % this.size.y;
1203 if (res < 0)
1204 res += this.size.y;
1205 return res;
1206 }
1207
1208 // Stop at the first capture found
1209 atLeastOneCapture(color) {
1210 color = color || this.turn;
1211 const oppCol = C.GetOppCol(color);
1212 for (let i = 0; i < this.size.x; i++) {
1213 for (let j = 0; j < this.size.y; j++) {
1214 if (this.board[i][j] != "" && this.getColor(i, j) == color) {
1215 const allSpecs = this.pieces(color, i, j)
1216 let specs = allSpecs[this.getPieceType(i, j)];
1217 const attacks = specs.attack || specs.moves;
1218 for (let a of attacks) {
1219 outerLoop: for (let step of a.steps) {
1220 let [ii, jj] = [i + step[0], this.getY(j + step[1])];
1221 let stepCounter = 1;
1222 while (this.onBoard(ii, jj) && this.board[ii][jj] == "") {
1223 if (a.range <= stepCounter++)
1224 continue outerLoop;
1225 ii += step[0];
1226 jj = this.getY(jj + step[1]);
1227 }
1228 if (
1229 this.onBoard(ii, jj) &&
1230 this.getColor(ii, jj) == oppCol &&
1231 this.filterValid(
1232 [this.getBasicMove([i, j], [ii, jj])]
1233 ).length >= 1
1234 ) {
1235 return true;
1236 }
1237 }
1238 }
1239 }
1240 }
1241 }
1242 return false;
1243 }
1244
1245 getDropMovesFrom([c, p]) {
1246 // NOTE: by design, this.reserve[c][p] >= 1 on user click
1247 // (but not necessarily otherwise: atLeastOneMove() etc)
1248 if (this.reserve[c][p] == 0)
1249 return [];
1250 let moves = [];
1251 for (let i=0; i<this.size.x; i++) {
1252 for (let j=0; j<this.size.y; j++) {
1253 if (
1254 this.board[i][j] == "" &&
1255 (!this.enlightened || this.enlightened[i][j]) &&
1256 (
1257 p != "p" ||
1258 (c == 'w' && i < this.size.x - 1) ||
1259 (c == 'b' && i > 0)
1260 )
1261 ) {
1262 moves.push(
1263 new Move({
1264 start: {x: c, y: p},
1265 end: {x: i, y: j},
1266 appear: [new PiPo({x: i, y: j, c: c, p: p})],
1267 vanish: []
1268 })
1269 );
1270 }
1271 }
1272 }
1273 return moves;
1274 }
1275
1276 // All possible moves from selected square
1277 getPotentialMovesFrom(sq, color) {
1278 if (this.subTurnTeleport == 2)
1279 return [];
1280 if (typeof sq[0] == "string")
1281 return this.getDropMovesFrom(sq);
1282 if (this.isImmobilized(sq))
1283 return [];
1284 const piece = this.getPieceType(sq[0], sq[1]);
1285 let moves = this.getPotentialMovesOf(piece, sq);
1286 if (
1287 piece == "p" &&
1288 this.hasEnpassant &&
1289 this.epSquare
1290 ) {
1291 Array.prototype.push.apply(moves, this.getEnpassantCaptures(sq));
1292 }
1293 if (
1294 piece == "k" &&
1295 this.hasCastle &&
1296 this.castleFlags[color || this.turn].some(v => v < this.size.y)
1297 ) {
1298 Array.prototype.push.apply(moves, this.getCastleMoves(sq));
1299 }
1300 return this.postProcessPotentialMoves(moves);
1301 }
1302
1303 postProcessPotentialMoves(moves) {
1304 if (moves.length == 0)
1305 return [];
1306 const color = this.getColor(moves[0].start.x, moves[0].start.y);
1307 const oppCol = C.GetOppCol(color);
1308
1309 if (this.options["capture"] && this.atLeastOneCapture())
1310 moves = this.capturePostProcess(moves, oppCol);
1311
1312 if (this.options["atomic"])
1313 this.atomicPostProcess(moves, oppCol);
1314
1315 if (
1316 moves.length > 0 &&
1317 this.getPieceType(moves[0].start.x, moves[0].start.y) == "p"
1318 ) {
1319 this.pawnPostProcess(moves, color, oppCol);
1320 }
1321
1322 if (
1323 this.options["cannibal"] &&
1324 this.options["rifle"]
1325 ) {
1326 // In this case a rifle-capture from last rank may promote a pawn
1327 this.riflePromotePostProcess(moves, color);
1328 }
1329
1330 return moves;
1331 }
1332
1333 capturePostProcess(moves, oppCol) {
1334 // Filter out non-capturing moves (not using m.vanish because of
1335 // self captures of Recycle and Teleport).
1336 return moves.filter(m => {
1337 return (
1338 this.board[m.end.x][m.end.y] != "" &&
1339 this.getColor(m.end.x, m.end.y) == oppCol
1340 );
1341 });
1342 }
1343
1344 atomicPostProcess(moves, oppCol) {
1345 moves.forEach(m => {
1346 if (
1347 this.board[m.end.x][m.end.y] != "" &&
1348 this.getColor(m.end.x, m.end.y) == oppCol
1349 ) {
1350 // Explosion!
1351 let steps = [
1352 [-1, -1],
1353 [-1, 0],
1354 [-1, 1],
1355 [0, -1],
1356 [0, 1],
1357 [1, -1],
1358 [1, 0],
1359 [1, 1]
1360 ];
1361 for (let step of steps) {
1362 let x = m.end.x + step[0];
1363 let y = this.getY(m.end.y + step[1]);
1364 if (
1365 this.onBoard(x, y) &&
1366 this.board[x][y] != "" &&
1367 this.getPieceType(x, y) != "p"
1368 ) {
1369 m.vanish.push(
1370 new PiPo({
1371 p: this.getPiece(x, y),
1372 c: this.getColor(x, y),
1373 x: x,
1374 y: y
1375 })
1376 );
1377 }
1378 }
1379 if (!this.options["rifle"])
1380 m.appear.pop(); //nothing appears
1381 }
1382 });
1383 }
1384
1385 pawnPostProcess(moves, color, oppCol) {
1386 let moreMoves = [];
1387 const lastRank = (color == "w" ? 0 : this.size.x - 1);
1388 const initPiece = this.getPiece(moves[0].start.x, moves[0].start.y);
1389 moves.forEach(m => {
1390 const [x1, y1] = [m.start.x, m.start.y];
1391 const [x2, y2] = [m.end.x, m.end.y];
1392 const promotionOk = (
1393 x2 == lastRank &&
1394 (!this.options["rifle"] || this.board[x2][y2] == "")
1395 );
1396 if (!promotionOk)
1397 return; //nothing to do
1398 if (this.options["pawnfall"]) {
1399 m.appear.shift();
1400 return;
1401 }
1402 let finalPieces = ["p"];
1403 if (
1404 this.options["cannibal"] &&
1405 this.board[x2][y2] != "" &&
1406 this.getColor(x2, y2) == oppCol
1407 ) {
1408 finalPieces = [this.getPieceType(x2, y2)];
1409 }
1410 else
1411 finalPieces = this.pawnPromotions;
1412 m.appear[0].p = finalPieces[0];
1413 if (initPiece == "!") //cannibal king-pawn
1414 m.appear[0].p = C.CannibalKingCode[finalPieces[0]];
1415 for (let i=1; i<finalPieces.length; i++) {
1416 const piece = finalPieces[i];
1417 const tr = {
1418 c: color,
1419 p: (initPiece != "!" ? piece : C.CannibalKingCode[piece])
1420 };
1421 let newMove = this.getBasicMove([x1, y1], [x2, y2], tr);
1422 moreMoves.push(newMove);
1423 }
1424 });
1425 Array.prototype.push.apply(moves, moreMoves);
1426 }
1427
1428 riflePromotePostProcess(moves, color) {
1429 const lastRank = (color == "w" ? 0 : this.size.x - 1);
1430 let newMoves = [];
1431 moves.forEach(m => {
1432 if (
1433 m.start.x == lastRank &&
1434 m.appear.length >= 1 &&
1435 m.appear[0].p == "p" &&
1436 m.appear[0].x == m.start.x &&
1437 m.appear[0].y == m.start.y
1438 ) {
1439 m.appear[0].p = this.pawnPromotions[0];
1440 for (let i=1; i<this.pawnPromotions.length; i++) {
1441 let newMv = JSON.parse(JSON.stringify(m));
1442 newMv.appear[0].p = this.pawnSpecs.promotions[i];
1443 newMoves.push(newMv);
1444 }
1445 }
1446 });
1447 Array.prototype.push.apply(moves, newMoves);
1448 }
1449
1450 // NOTE: using special symbols to not interfere with variants' pieces codes
1451 static get CannibalKings() {
1452 return {
1453 "!": "p",
1454 "#": "r",
1455 "$": "n",
1456 "%": "b",
1457 "*": "q",
1458 "k": "k"
1459 };
1460 }
1461
1462 static get CannibalKingCode() {
1463 return {
1464 "p": "!",
1465 "r": "#",
1466 "n": "$",
1467 "b": "%",
1468 "q": "*",
1469 "k": "k"
1470 };
1471 }
1472
1473 isKing(symbol) {
1474 return !!C.CannibalKings[symbol];
1475 }
1476
1477 // For Madrasi:
1478 // (redefined in Baroque etc, where Madrasi condition doesn't make sense)
1479 isImmobilized([x, y]) {
1480 if (!this.options["madrasi"])
1481 return false;
1482 const color = this.getColor(x, y);
1483 const oppCol = C.GetOppCol(color);
1484 const piece = this.getPieceType(x, y); //ok not cannibal king
1485 const stepSpec = this.pieces(color, x, y)[piece];
1486 const attacks = stepSpec.attack || stepSpec.moves;
1487 for (let a of attacks) {
1488 outerLoop: for (let step of a.steps) {
1489 let [i, j] = [x + step[0], y + step[1]];
1490 let stepCounter = 1;
1491 while (this.onBoard(i, j) && this.board[i][j] == "") {
1492 if (a.range <= stepCounter++)
1493 continue outerLoop;
1494 i += step[0];
1495 j = this.getY(j + step[1]);
1496 }
1497 if (
1498 this.onBoard(i, j) &&
1499 this.getColor(i, j) == oppCol &&
1500 this.getPieceType(i, j) == piece
1501 ) {
1502 return true;
1503 }
1504 }
1505 }
1506 return false;
1507 }
1508
1509 canStepOver(i, j) {
1510 // In some variants, objects on boards don't stop movement (Chakart)
1511 return this.board[i][j] == "";
1512 }
1513
1514 // Generic method to find possible moves of "sliding or jumping" pieces
1515 getPotentialMovesOf(piece, [x, y]) {
1516 const color = this.getColor(x, y);
1517 const stepSpec = this.pieces(color, x, y)[piece];
1518 let moves = [];
1519 // Next 3 for Cylinder mode:
1520 let explored = {};
1521 let segments = [];
1522 let segStart = [];
1523
1524 const addMove = (start, end) => {
1525 let newMove = this.getBasicMove(start, end);
1526 if (segments.length > 0) {
1527 newMove.segments = JSON.parse(JSON.stringify(segments));
1528 newMove.segments.push([[segStart[0], segStart[1]], [end[0], end[1]]]);
1529 }
1530 moves.push(newMove);
1531 };
1532
1533 const findAddMoves = (type, stepArray) => {
1534 for (let s of stepArray) {
1535 outerLoop: for (let step of s.steps) {
1536 segments = [];
1537 segStart = [x, y];
1538 let [i, j] = [x, y];
1539 let stepCounter = 0;
1540 while (
1541 this.onBoard(i, j) &&
1542 (this.canStepOver(i, j) || (i == x && j == y))
1543 ) {
1544 if (
1545 type != "attack" &&
1546 !explored[i + "." + j] &&
1547 (i != x || j != y)
1548 ) {
1549 explored[i + "." + j] = true;
1550 addMove([x, y], [i, j]);
1551 }
1552 if (s.range <= stepCounter++)
1553 continue outerLoop;
1554 const oldIJ = [i, j];
1555 i += step[0];
1556 j = this.getY(j + step[1]);
1557 if (Math.abs(j - oldIJ[1]) > 1) {
1558 // Boundary between segments (cylinder mode)
1559 segments.push([[segStart[0], segStart[1]], oldIJ]);
1560 segStart = [i, j];
1561 }
1562 }
1563 if (!this.onBoard(i, j))
1564 continue;
1565 const pieceIJ = this.getPieceType(i, j);
1566 if (
1567 type != "moveonly" &&
1568 !explored[i + "." + j] &&
1569 (
1570 !this.options["zen"] ||
1571 pieceIJ == "k"
1572 ) &&
1573 (
1574 this.canTake([x, y], [i, j]) ||
1575 (
1576 (this.options["recycle"] || this.options["teleport"]) &&
1577 pieceIJ != "k"
1578 )
1579 )
1580 ) {
1581 explored[i + "." + j] = true;
1582 addMove([x, y], [i, j]);
1583 }
1584 }
1585 }
1586 };
1587
1588 const specialAttack = !!stepSpec.attack;
1589 if (specialAttack)
1590 findAddMoves("attack", stepSpec.attack);
1591 findAddMoves(specialAttack ? "moveonly" : "all", stepSpec.moves);
1592 if (this.options["zen"]) {
1593 Array.prototype.push.apply(moves,
1594 this.findCapturesOn([x, y], {zen: true}));
1595 }
1596 return moves;
1597 }
1598
1599 // Search for enemy (or not) pieces attacking [x, y]
1600 findCapturesOn([x, y], args) {
1601 let moves = [];
1602 if (!args.oppCol)
1603 args.oppCol = C.GetOppCol(this.getColor(x, y) || this.turn);
1604 for (let i=0; i<this.size.x; i++) {
1605 for (let j=0; j<this.size.y; j++) {
1606 if (
1607 this.board[i][j] != "" &&
1608 this.getColor(i, j) == args.oppCol &&
1609 !this.isImmobilized([i, j])
1610 ) {
1611 if (args.zen && this.isKing(this.getPiece(i, j)))
1612 continue; //king not captured in this way
1613 const stepSpec =
1614 this.pieces(args.oppCol, i, j)[this.getPieceType(i, j)];
1615 const attacks = stepSpec.attack || stepSpec.moves;
1616 for (let a of attacks) {
1617 for (let s of a.steps) {
1618 // Quick check: if step isn't compatible, don't even try
1619 if (!C.CompatibleStep([i, j], [x, y], s, a.range))
1620 continue;
1621 // Finally verify that nothing stand in-between
1622 let [ii, jj] = [i + s[0], this.getY(j + s[1])];
1623 let stepCounter = 1;
1624 while (
1625 this.onBoard(ii, jj) &&
1626 this.board[ii][jj] == "" &&
1627 (ii != x || jj != y) //condition to attack empty squares too
1628 ) {
1629 ii += s[0];
1630 jj = this.getY(jj + s[1]);
1631 }
1632 if (ii == x && jj == y) {
1633 if (args.zen)
1634 // Reverse capture:
1635 moves.push(this.getBasicMove([x, y], [i, j]));
1636 else
1637 moves.push(this.getBasicMove([i, j], [x, y]));
1638 if (args.one)
1639 return moves; //test for underCheck
1640 }
1641 }
1642 }
1643 }
1644 }
1645 }
1646 return moves;
1647 }
1648
1649 static CompatibleStep([x1, y1], [x2, y2], step, range) {
1650 const rx = (x2 - x1) / step[0],
1651 ry = (y2 - y1) / step[1];
1652 if (
1653 (!Number.isFinite(rx) && !Number.isNaN(rx)) ||
1654 (!Number.isFinite(ry) && !Number.isNaN(ry))
1655 ) {
1656 return false;
1657 }
1658 let distance = (Number.isNaN(rx) ? ry : rx);
1659 // TODO: 1e-7 here is totally arbitrary
1660 if (Math.abs(distance - Math.round(distance)) > 1e-7)
1661 return false;
1662 distance = Math.round(distance); //in case of (numerical...)
1663 if (range < distance)
1664 return false;
1665 return true;
1666 }
1667
1668 // Build a regular move from its initial and destination squares.
1669 // tr: transformation
1670 getBasicMove([sx, sy], [ex, ey], tr) {
1671 const initColor = this.getColor(sx, sy);
1672 const initPiece = this.getPiece(sx, sy);
1673 const destColor = (this.board[ex][ey] != "" ? this.getColor(ex, ey) : "");
1674 let mv = new Move({
1675 appear: [],
1676 vanish: [],
1677 start: {x: sx, y: sy},
1678 end: {x: ex, y: ey}
1679 });
1680 if (
1681 !this.options["rifle"] ||
1682 this.board[ex][ey] == "" ||
1683 destColor == initColor //Recycle, Teleport
1684 ) {
1685 mv.appear = [
1686 new PiPo({
1687 x: ex,
1688 y: ey,
1689 c: !!tr ? tr.c : initColor,
1690 p: !!tr ? tr.p : initPiece
1691 })
1692 ];
1693 mv.vanish = [
1694 new PiPo({
1695 x: sx,
1696 y: sy,
1697 c: initColor,
1698 p: initPiece
1699 })
1700 ];
1701 }
1702 if (this.board[ex][ey] != "") {
1703 mv.vanish.push(
1704 new PiPo({
1705 x: ex,
1706 y: ey,
1707 c: this.getColor(ex, ey),
1708 p: this.getPiece(ex, ey)
1709 })
1710 );
1711 if (this.options["cannibal"] && destColor != initColor) {
1712 const lastIdx = mv.vanish.length - 1;
1713 let trPiece = mv.vanish[lastIdx].p;
1714 if (this.isKing(this.getPiece(sx, sy)))
1715 trPiece = C.CannibalKingCode[trPiece];
1716 if (mv.appear.length >= 1)
1717 mv.appear[0].p = trPiece;
1718 else if (this.options["rifle"]) {
1719 mv.appear.unshift(
1720 new PiPo({
1721 x: sx,
1722 y: sy,
1723 c: initColor,
1724 p: trPiece
1725 })
1726 );
1727 mv.vanish.unshift(
1728 new PiPo({
1729 x: sx,
1730 y: sy,
1731 c: initColor,
1732 p: initPiece
1733 })
1734 );
1735 }
1736 }
1737 }
1738 return mv;
1739 }
1740
1741 // En-passant square, if any
1742 getEpSquare(moveOrSquare) {
1743 if (typeof moveOrSquare === "string") {
1744 const square = moveOrSquare;
1745 if (square == "-")
1746 return undefined;
1747 return C.SquareToCoords(square);
1748 }
1749 // Argument is a move:
1750 const move = moveOrSquare;
1751 const s = move.start,
1752 e = move.end;
1753 if (
1754 s.y == e.y &&
1755 Math.abs(s.x - e.x) == 2 &&
1756 // Next conditions for variants like Atomic or Rifle, Recycle...
1757 (move.appear.length > 0 && move.appear[0].p == "p") &&
1758 (move.vanish.length > 0 && move.vanish[0].p == "p")
1759 ) {
1760 return {
1761 x: (s.x + e.x) / 2,
1762 y: s.y
1763 };
1764 }
1765 return undefined; //default
1766 }
1767
1768 // Special case of en-passant captures: treated separately
1769 getEnpassantCaptures([x, y]) {
1770 const color = this.getColor(x, y);
1771 const shiftX = (color == 'w' ? -1 : 1);
1772 const oppCol = C.GetOppCol(color);
1773 let enpassantMove = null;
1774 if (
1775 !!this.epSquare &&
1776 this.epSquare.x == x + shiftX &&
1777 Math.abs(this.getY(this.epSquare.y - y)) == 1 &&
1778 this.getColor(x, this.epSquare.y) == oppCol //Doublemove guard...
1779 ) {
1780 const [epx, epy] = [this.epSquare.x, this.epSquare.y];
1781 this.board[epx][epy] = oppCol + "p";
1782 enpassantMove = this.getBasicMove([x, y], [epx, epy]);
1783 this.board[epx][epy] = "";
1784 const lastIdx = enpassantMove.vanish.length - 1; //think Rifle
1785 enpassantMove.vanish[lastIdx].x = x;
1786 }
1787 return !!enpassantMove ? [enpassantMove] : [];
1788 }
1789
1790 // "castleInCheck" arg to let some variants castle under check
1791 getCastleMoves([x, y], finalSquares, castleInCheck, castleWith) {
1792 const c = this.getColor(x, y);
1793
1794 // Castling ?
1795 const oppCol = C.GetOppCol(c);
1796 let moves = [];
1797 // King, then rook:
1798 finalSquares =
1799 finalSquares || [ [2, 3], [this.size.y - 2, this.size.y - 3] ];
1800 const castlingKing = this.getPiece(x, y);
1801 castlingCheck: for (
1802 let castleSide = 0;
1803 castleSide < 2;
1804 castleSide++ //large, then small
1805 ) {
1806 if (this.castleFlags[c][castleSide] >= this.size.y)
1807 continue;
1808 // If this code is reached, rook and king are on initial position
1809
1810 // NOTE: in some variants this is not a rook
1811 const rookPos = this.castleFlags[c][castleSide];
1812 const castlingPiece = this.getPiece(x, rookPos);
1813 if (
1814 this.board[x][rookPos] == "" ||
1815 this.getColor(x, rookPos) != c ||
1816 (!!castleWith && !castleWith.includes(castlingPiece))
1817 ) {
1818 // Rook is not here, or changed color (see Benedict)
1819 continue;
1820 }
1821 // Nothing on the path of the king ? (and no checks)
1822 const finDist = finalSquares[castleSide][0] - y;
1823 let step = finDist / Math.max(1, Math.abs(finDist));
1824 let i = y;
1825 do {
1826 if (
1827 (!castleInCheck && this.underCheck([x, i], oppCol)) ||
1828 (
1829 this.board[x][i] != "" &&
1830 // NOTE: next check is enough, because of chessboard constraints
1831 (this.getColor(x, i) != c || ![rookPos, y].includes(i))
1832 )
1833 ) {
1834 continue castlingCheck;
1835 }
1836 i += step;
1837 } while (i != finalSquares[castleSide][0]);
1838 // Nothing on the path to the rook?
1839 step = (castleSide == 0 ? -1 : 1);
1840 for (i = y + step; i != rookPos; i += step) {
1841 if (this.board[x][i] != "")
1842 continue castlingCheck;
1843 }
1844
1845 // Nothing on final squares, except maybe king and castling rook?
1846 for (i = 0; i < 2; i++) {
1847 if (
1848 finalSquares[castleSide][i] != rookPos &&
1849 this.board[x][finalSquares[castleSide][i]] != "" &&
1850 (
1851 finalSquares[castleSide][i] != y ||
1852 this.getColor(x, finalSquares[castleSide][i]) != c
1853 )
1854 ) {
1855 continue castlingCheck;
1856 }
1857 }
1858
1859 // If this code is reached, castle is valid
1860 moves.push(
1861 new Move({
1862 appear: [
1863 new PiPo({
1864 x: x,
1865 y: finalSquares[castleSide][0],
1866 p: castlingKing,
1867 c: c
1868 }),
1869 new PiPo({
1870 x: x,
1871 y: finalSquares[castleSide][1],
1872 p: castlingPiece,
1873 c: c
1874 })
1875 ],
1876 vanish: [
1877 // King might be initially disguised (Titan...)
1878 new PiPo({ x: x, y: y, p: castlingKing, c: c }),
1879 new PiPo({ x: x, y: rookPos, p: castlingPiece, c: c })
1880 ],
1881 end:
1882 Math.abs(y - rookPos) <= 2
1883 ? {x: x, y: rookPos}
1884 : {x: x, y: y + 2 * (castleSide == 0 ? -1 : 1)}
1885 })
1886 );
1887 }
1888
1889 return moves;
1890 }
1891
1892 ////////////////////
1893 // MOVES VALIDATION
1894
1895 // Is (king at) given position under check by "oppCol" ?
1896 underCheck([x, y], oppCol) {
1897 if (this.options["taking"] || this.options["dark"])
1898 return false;
1899 return (
1900 this.findCapturesOn([x, y], {oppCol: oppCol, one: true}).length >= 1
1901 );
1902 }
1903
1904 // Stop at first king found (TODO: multi-kings)
1905 searchKingPos(color) {
1906 for (let i=0; i < this.size.x; i++) {
1907 for (let j=0; j < this.size.y; j++) {
1908 if (this.getColor(i, j) == color && this.isKing(this.getPiece(i, j)))
1909 return [i, j];
1910 }
1911 }
1912 return [-1, -1]; //king not found
1913 }
1914
1915 // Some variants (e.g. Refusal) may need to check opponent moves too
1916 filterValid(moves, color) {
1917 if (moves.length == 0)
1918 return [];
1919 if (!color)
1920 color = this.turn;
1921 const oppCol = C.GetOppCol(color);
1922 if (this.options["balance"] && [1, 3].includes(this.movesCount)) {
1923 // Forbid moves either giving check or exploding opponent's king:
1924 const oppKingPos = this.searchKingPos(oppCol);
1925 moves = moves.filter(m => {
1926 if (
1927 m.vanish.some(v => v.c == oppCol && v.p == "k") &&
1928 m.appear.every(a => a.c != oppCol || a.p != "k")
1929 )
1930 return false;
1931 this.playOnBoard(m);
1932 const res = !this.underCheck(oppKingPos, color);
1933 this.undoOnBoard(m);
1934 return res;
1935 });
1936 }
1937 if (this.options["taking"] || this.options["dark"])
1938 return moves;
1939 const kingPos = this.searchKingPos(color);
1940 let filtered = {}; //avoid re-checking similar moves (promotions...)
1941 return moves.filter(m => {
1942 const key = m.start.x + m.start.y + '.' + m.end.x + m.end.y;
1943 if (!filtered[key]) {
1944 this.playOnBoard(m);
1945 let square = kingPos,
1946 res = true; //a priori valid
1947 if (m.vanish.some(v => {
1948 return C.CannibalKings[v.p] && v.c == color;
1949 })) {
1950 // Search king in appear array:
1951 const newKingIdx =
1952 m.appear.findIndex(a => {
1953 return C.CannibalKings[a.p] && a.c == color;
1954 });
1955 if (newKingIdx >= 0)
1956 square = [m.appear[newKingIdx].x, m.appear[newKingIdx].y];
1957 else
1958 res = false;
1959 }
1960 res &&= !this.underCheck(square, oppCol);
1961 this.undoOnBoard(m);
1962 filtered[key] = res;
1963 return res;
1964 }
1965 return filtered[key];
1966 });
1967 }
1968
1969 /////////////////
1970 // MOVES PLAYING
1971
1972 // Aggregate flags into one object
1973 aggregateFlags() {
1974 return this.castleFlags;
1975 }
1976
1977 // Reverse operation
1978 disaggregateFlags(flags) {
1979 this.castleFlags = flags;
1980 }
1981
1982 // Apply a move on board
1983 playOnBoard(move) {
1984 for (let psq of move.vanish)
1985 this.board[psq.x][psq.y] = "";
1986 for (let psq of move.appear)
1987 this.board[psq.x][psq.y] = psq.c + psq.p;
1988 }
1989 // Un-apply the played move
1990 undoOnBoard(move) {
1991 for (let psq of move.appear)
1992 this.board[psq.x][psq.y] = "";
1993 for (let psq of move.vanish)
1994 this.board[psq.x][psq.y] = psq.c + psq.p;
1995 }
1996
1997 updateCastleFlags(move) {
1998 // Update castling flags if start or arrive from/at rook/king locations
1999 move.appear.concat(move.vanish).forEach(psq => {
2000 if (
2001 this.board[psq.x][psq.y] != "" &&
2002 this.getPieceType(psq.x, psq.y) == "k"
2003 ) {
2004 this.castleFlags[psq.c] = [this.size.y, this.size.y];
2005 }
2006 // NOTE: not "else if" because king can capture enemy rook...
2007 let c = "";
2008 if (psq.x == 0)
2009 c = "b";
2010 else if (psq.x == this.size.x - 1)
2011 c = "w";
2012 if (c != "") {
2013 const fidx = this.castleFlags[c].findIndex(f => f == psq.y);
2014 if (fidx >= 0)
2015 this.castleFlags[c][fidx] = this.size.y;
2016 }
2017 });
2018 }
2019
2020 prePlay(move) {
2021 if (
2022 this.hasCastle &&
2023 // If flags already off, no need to re-check:
2024 Object.keys(this.castleFlags).some(c => {
2025 return this.castleFlags[c].some(val => val < this.size.y)})
2026 ) {
2027 this.updateCastleFlags(move);
2028 }
2029 if (this.options["crazyhouse"]) {
2030 move.vanish.forEach(v => {
2031 const square = C.CoordsToSquare({x: v.x, y: v.y});
2032 if (this.ispawn[square])
2033 delete this.ispawn[square];
2034 });
2035 if (move.appear.length > 0 && move.vanish.length > 0) {
2036 // Assumption: something is moving
2037 const initSquare = C.CoordsToSquare(move.start);
2038 const destSquare = C.CoordsToSquare(move.end);
2039 if (
2040 this.ispawn[initSquare] ||
2041 (move.vanish[0].p == "p" && move.appear[0].p != "p")
2042 ) {
2043 this.ispawn[destSquare] = true;
2044 }
2045 else if (
2046 this.ispawn[destSquare] &&
2047 this.getColor(move.end.x, move.end.y) != move.vanish[0].c
2048 ) {
2049 move.vanish[1].p = "p";
2050 delete this.ispawn[destSquare];
2051 }
2052 }
2053 }
2054 const minSize = Math.min(move.appear.length, move.vanish.length);
2055 if (
2056 this.hasReserve &&
2057 // Warning; atomic pawn removal isn't a capture
2058 (!this.options["atomic"] || !this.rempawn || this.movesCount >= 1)
2059 ) {
2060 const color = this.turn;
2061 for (let i=minSize; i<move.appear.length; i++) {
2062 // Something appears = dropped on board (some exceptions, Chakart...)
2063 if (move.appear[i].c == color) {
2064 const piece = move.appear[i].p;
2065 this.updateReserve(color, piece, this.reserve[color][piece] - 1);
2066 }
2067 }
2068 for (let i=minSize; i<move.vanish.length; i++) {
2069 // Something vanish: add to reserve except if recycle & opponent
2070 if (
2071 this.options["crazyhouse"] ||
2072 (this.options["recycle"] && move.vanish[i].c == color)
2073 ) {
2074 const piece = move.vanish[i].p;
2075 this.updateReserve(color, piece, this.reserve[color][piece] + 1);
2076 }
2077 }
2078 }
2079 }
2080
2081 play(move) {
2082 this.prePlay(move);
2083 if (this.hasEnpassant)
2084 this.epSquare = this.getEpSquare(move);
2085 this.playOnBoard(move);
2086 this.postPlay(move);
2087 }
2088
2089 postPlay(move) {
2090 const color = this.turn;
2091 const oppCol = C.GetOppCol(color);
2092 if (this.options["dark"])
2093 this.updateEnlightened();
2094 if (this.options["teleport"]) {
2095 if (
2096 this.subTurnTeleport == 1 &&
2097 move.vanish.length > move.appear.length &&
2098 move.vanish[move.vanish.length - 1].c == color
2099 ) {
2100 const v = move.vanish[move.vanish.length - 1];
2101 this.captured = {x: v.x, y: v.y, c: v.c, p: v.p};
2102 this.subTurnTeleport = 2;
2103 return;
2104 }
2105 this.subTurnTeleport = 1;
2106 this.captured = null;
2107 }
2108 if (this.options["balance"]) {
2109 if (![1, 3].includes(this.movesCount))
2110 this.turn = oppCol;
2111 }
2112 else {
2113 if (
2114 (
2115 this.options["doublemove"] &&
2116 this.movesCount >= 1 &&
2117 this.subTurn == 1
2118 ) ||
2119 (this.options["progressive"] && this.subTurn <= this.movesCount)
2120 ) {
2121 const oppKingPos = this.searchKingPos(oppCol);
2122 if (
2123 oppKingPos[0] >= 0 &&
2124 (
2125 this.options["taking"] ||
2126 !this.underCheck(oppKingPos, color)
2127 )
2128 ) {
2129 this.subTurn++;
2130 return;
2131 }
2132 }
2133 this.turn = oppCol;
2134 }
2135 this.movesCount++;
2136 this.subTurn = 1;
2137 }
2138
2139 // "Stop at the first move found"
2140 atLeastOneMove(color) {
2141 color = color || this.turn;
2142 for (let i = 0; i < this.size.x; i++) {
2143 for (let j = 0; j < this.size.y; j++) {
2144 if (this.board[i][j] != "" && this.getColor(i, j) == color) {
2145 // NOTE: in fact searching for all potential moves from i,j.
2146 // I don't believe this is an issue, for now at least.
2147 const moves = this.getPotentialMovesFrom([i, j]);
2148 if (moves.some(m => this.filterValid([m]).length >= 1))
2149 return true;
2150 }
2151 }
2152 }
2153 if (this.hasReserve && this.reserve[color]) {
2154 for (let p of Object.keys(this.reserve[color])) {
2155 const moves = this.getDropMovesFrom([color, p]);
2156 if (moves.some(m => this.filterValid([m]).length >= 1))
2157 return true;
2158 }
2159 }
2160 return false;
2161 }
2162
2163 // What is the score ? (Interesting if game is over)
2164 getCurrentScore(move) {
2165 const color = this.turn;
2166 const oppCol = C.GetOppCol(color);
2167 const kingPos = [this.searchKingPos(color), this.searchKingPos(oppCol)];
2168 if (kingPos[0][0] < 0 && kingPos[1][0] < 0)
2169 return "1/2";
2170 if (kingPos[0][0] < 0)
2171 return (color == "w" ? "0-1" : "1-0");
2172 if (kingPos[1][0] < 0)
2173 return (color == "w" ? "1-0" : "0-1");
2174 if (this.atLeastOneMove())
2175 return "*";
2176 // No valid move: stalemate or checkmate?
2177 if (!this.underCheck(kingPos[0], color))
2178 return "1/2";
2179 // OK, checkmate
2180 return (color == "w" ? "0-1" : "1-0");
2181 }
2182
2183 playVisual(move, r) {
2184 move.vanish.forEach(v => {
2185 this.g_pieces[v.x][v.y].remove();
2186 this.g_pieces[v.x][v.y] = null;
2187 });
2188 let chessboard =
2189 document.getElementById(this.containerId).querySelector(".chessboard");
2190 if (!r)
2191 r = chessboard.getBoundingClientRect();
2192 const pieceWidth = this.getPieceWidth(r.width);
2193 move.appear.forEach(a => {
2194 this.g_pieces[a.x][a.y] = document.createElement("piece");
2195 C.AddClass_es(this.g_pieces[a.x][a.y],
2196 this.pieces(a.c, a.x, a.y)[a.p]["class"]);
2197 this.g_pieces[a.x][a.y].classList.add(C.GetColorClass(a.c));
2198 this.g_pieces[a.x][a.y].style.width = pieceWidth + "px";
2199 this.g_pieces[a.x][a.y].style.height = pieceWidth + "px";
2200 const [ip, jp] = this.getPixelPosition(a.x, a.y, r);
2201 // Translate coordinates to use chessboard as reference:
2202 this.g_pieces[a.x][a.y].style.transform =
2203 `translate(${ip - r.x}px,${jp - r.y}px)`;
2204 if (this.enlightened && !this.enlightened[a.x][a.y])
2205 this.g_pieces[a.x][a.y].classList.add("hidden");
2206 chessboard.appendChild(this.g_pieces[a.x][a.y]);
2207 });
2208 if (this.options["dark"])
2209 this.graphUpdateEnlightened();
2210 }
2211
2212 playPlusVisual(move, r) {
2213 this.play(move);
2214 this.playVisual(move, r);
2215 this.afterPlay(move); //user method
2216 }
2217
2218 getMaxDistance(r) {
2219 // Works for all rectangular boards:
2220 return Math.sqrt(r.width ** 2 + r.height ** 2);
2221 }
2222
2223 getDomPiece(x, y) {
2224 return (typeof x == "string" ? this.r_pieces : this.g_pieces)[x][y];
2225 }
2226
2227 animate(move, callback) {
2228 if (this.noAnimate || move.noAnimate) {
2229 callback();
2230 return;
2231 }
2232 let initPiece = this.getDomPiece(move.start.x, move.start.y);
2233 // NOTE: cloning generally not required, but light enough, and simpler
2234 let movingPiece = initPiece.cloneNode();
2235 initPiece.style.opacity = "0";
2236 let container =
2237 document.getElementById(this.containerId)
2238 const r = container.querySelector(".chessboard").getBoundingClientRect();
2239 if (typeof move.start.x == "string") {
2240 // Need to bound width/height (was 100% for reserve pieces)
2241 const pieceWidth = this.getPieceWidth(r.width);
2242 movingPiece.style.width = pieceWidth + "px";
2243 movingPiece.style.height = pieceWidth + "px";
2244 }
2245 const maxDist = this.getMaxDistance(r);
2246 const apparentColor = this.getColor(move.start.x, move.start.y);
2247 const pieces = this.pieces(apparentColor, move.start.x, move.start.y);
2248 if (move.drag) {
2249 const startCode = this.getPiece(move.start.x, move.start.y);
2250 C.RemoveClass_es(movingPiece, pieces[startCode]["class"]);
2251 C.AddClass_es(movingPiece, pieces[move.drag.p]["class"]);
2252 if (apparentColor != move.drag.c) {
2253 movingPiece.classList.remove(C.GetColorClass(apparentColor));
2254 movingPiece.classList.add(C.GetColorClass(move.drag.c));
2255 }
2256 }
2257 container.appendChild(movingPiece);
2258 const animateSegment = (index, cb) => {
2259 // NOTE: move.drag could be generalized per-segment (usage?)
2260 const [i1, j1] = move.segments[index][0];
2261 const [i2, j2] = move.segments[index][1];
2262 const dep = this.getPixelPosition(i1, j1, r);
2263 const arr = this.getPixelPosition(i2, j2, r);
2264 movingPiece.style.transitionDuration = "0s";
2265 movingPiece.style.transform = `translate(${dep[0]}px, ${dep[1]}px)`;
2266 const distance =
2267 Math.sqrt((arr[0] - dep[0]) ** 2 + (arr[1] - dep[1]) ** 2);
2268 const duration = 0.2 + (distance / maxDist) * 0.3;
2269 // TODO: unclear why we need this new delay below:
2270 setTimeout(() => {
2271 movingPiece.style.transitionDuration = duration + "s";
2272 // movingPiece is child of container: no need to adjust coordinates
2273 movingPiece.style.transform = `translate(${arr[0]}px, ${arr[1]}px)`;
2274 setTimeout(cb, duration * 1000);
2275 }, 50);
2276 };
2277 if (!move.segments) {
2278 move.segments = [
2279 [[move.start.x, move.start.y], [move.end.x, move.end.y]]
2280 ];
2281 }
2282 let index = 0;
2283 const animateSegmentCallback = () => {
2284 if (index < move.segments.length)
2285 animateSegment(index++, animateSegmentCallback);
2286 else {
2287 movingPiece.remove();
2288 initPiece.style.opacity = "1";
2289 callback();
2290 }
2291 };
2292 animateSegmentCallback();
2293 }
2294
2295 playReceivedMove(moves, callback) {
2296 const launchAnimation = () => {
2297 const r = container.querySelector(".chessboard").getBoundingClientRect();
2298 const animateRec = i => {
2299 this.animate(moves[i], () => {
2300 this.play(moves[i]);
2301 this.playVisual(moves[i], r);
2302 if (i < moves.length - 1)
2303 setTimeout(() => animateRec(i+1), 300);
2304 else
2305 callback();
2306 });
2307 };
2308 animateRec(0);
2309 };
2310 // Delay if user wasn't focused:
2311 const checkDisplayThenAnimate = (delay) => {
2312 if (container.style.display == "none") {
2313 alert("New move! Let's go back to game...");
2314 document.getElementById("gameInfos").style.display = "none";
2315 container.style.display = "block";
2316 setTimeout(launchAnimation, 700);
2317 }
2318 else
2319 setTimeout(launchAnimation, delay || 0);
2320 };
2321 let container = document.getElementById(this.containerId);
2322 if (document.hidden) {
2323 document.onvisibilitychange = () => {
2324 document.onvisibilitychange = undefined;
2325 checkDisplayThenAnimate(700);
2326 };
2327 }
2328 else
2329 checkDisplayThenAnimate();
2330 }
2331
2332 };