X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=base_rules.js;h=8eed3d35250e521b0a6cb78d4a85d67222c8341d;hb=d6d0a46e5c8c1d9176f4a9e9c44a4b5f2ed791e7;hp=ebf8f1e388555c9ec28efaf0805797ab5aac29cd;hpb=462947f0a6c5f33033bbee5d42d38149be6d51cb;p=xogo.git

diff --git a/base_rules.js b/base_rules.js
index ebf8f1e..8eed3d3 100644
--- a/base_rules.js
+++ b/base_rules.js
@@ -1,5 +1,5 @@
-import { Random } from "/utils/alea.js";
-import { ArrayFun } from "/utils/array.js";
+import {Random} from "/utils/alea.js";
+import {ArrayFun} from "/utils/array.js";
 import PiPo from "/utils/PiPo.js";
 import Move from "/utils/Move.js";
 
@@ -116,6 +116,11 @@ export default class ChessRules {
     return false;
   }
 
+  // Some variants reveal moves only after both players played
+  get hideMoves() {
+    return false;
+  }
+
   // Some variants use click infos:
   doClick(coords) {
     if (typeof coords.x != "number")
@@ -523,20 +528,16 @@ export default class ChessRules {
       (oldV,newV) => oldV + (this.reserve[c][newV] > 0 ? 1 : 0), 0);
   }
 
-  static AddClass_es(piece, class_es) {
+  static AddClass_es(elt, class_es) {
     if (!Array.isArray(class_es))
       class_es = [class_es];
-    class_es.forEach(cl => {
-      piece.classList.add(cl);
-    });
+    class_es.forEach(cl => elt.classList.add(cl));
   }
 
-  static RemoveClass_es(piece, class_es) {
+  static RemoveClass_es(elt, class_es) {
     if (!Array.isArray(class_es))
       class_es = [class_es];
-    class_es.forEach(cl => {
-      piece.classList.remove(cl);
-    });
+    class_es.forEach(cl => elt.classList.remove(cl));
   }
 
   // Generally light square bottom-right
@@ -624,6 +625,8 @@ export default class ChessRules {
         class="chessboard_SVG">`;
     for (let i=0; i < this.size.x; i++) {
       for (let j=0; j < this.size.y; j++) {
+        if (!this.onBoard(i, j))
+          continue;
         const ii = (flipped ? this.size.x - 1 - i : i);
         const jj = (flipped ? this.size.y - 1 - j : j);
         let classes = this.getSquareColorClass(ii, jj);
@@ -1074,6 +1077,21 @@ export default class ChessRules {
     }
   }
 
+  displayMessage(elt, msg, classe_s, timeout) {
+    if (elt)
+      // Fixed element, e.g. for Dice Chess
+      elt.innerHTML = msg;
+    else {
+      // Temporary div (Chakart, Apocalypse...)
+      let divMsg = document.createElement("div");
+      C.AddClass_es(divMsg, classe_s);
+      divMsg.innerHTML = msg;
+      let container = document.getElementById(this.containerId);
+      container.appendChild(divMsg);
+      setTimeout(() => container.removeChild(divMsg), timeout);
+    }
+  }
+
   ////////////////
   // DARK METHODS
 
@@ -1474,7 +1492,7 @@ export default class ChessRules {
     let moves = [];
     for (let i=0; i<this.size.x; i++) {
       for (let j=0; j<this.size.y; j++) {
-        if (this.canDrop([c, p], [i, j])) {
+        if (this.onBoard(i, j) && this.canDrop([c, p], [i, j])) {
           let mv = new Move({
             start: {x: c, y: p},
             end: {x: i, y: j},
@@ -1527,18 +1545,18 @@ export default class ChessRules {
       moves = this.capturePostProcess(moves, oppCol);
 
     if (this.options["atomic"])
-      this.atomicPostProcess(moves, color, oppCol);
+      moves = this.atomicPostProcess(moves, color, oppCol);
 
     if (
       moves.length > 0 &&
       this.getPieceType(moves[0].start.x, moves[0].start.y) == "p"
     ) {
-      this.pawnPostProcess(moves, color, oppCol);
+      moves = this.pawnPostProcess(moves, color, oppCol);
     }
 
     if (this.options["cannibal"] && this.options["rifle"])
       // In this case a rifle-capture from last rank may promote a pawn
-      this.riflePromotePostProcess(moves, color);
+      moves = this.riflePromotePostProcess(moves, color);
 
     return moves;
   }
@@ -1610,6 +1628,7 @@ export default class ChessRules {
         m.next = mNext;
       }
     });
+    return moves;
   }
 
   pawnPostProcess(moves, color, oppCol) {
@@ -1629,7 +1648,7 @@ export default class ChessRules {
         m.appear.shift();
         return;
       }
-      let finalPieces = ["p"];
+      let finalPieces;
       if (
         this.options["cannibal"] &&
         this.board[x2][y2] != "" &&
@@ -1643,16 +1662,13 @@ export default class ChessRules {
       if (initPiece == "!") //cannibal king-pawn
         m.appear[0].p = C.CannibalKingCode[finalPieces[0]];
       for (let i=1; i<finalPieces.length; i++) {
+        let newMove = JSON.parse(JSON.stringify(m));
         const piece = finalPieces[i];
-        const tr = {
-          c: color,
-          p: (initPiece != "!" ? piece : C.CannibalKingCode[piece])
-        };
-        let newMove = this.getBasicMove([x1, y1], [x2, y2], tr);
+        m.appear[0].p = (initPiece != "!" ? piece : C.CannibalKingCode[piece]);
         moreMoves.push(newMove);
       }
     });
-    Array.prototype.push.apply(moves, moreMoves);
+    return moves.concat(moreMoves);
   }
 
   riflePromotePostProcess(moves, color) {
@@ -1674,7 +1690,7 @@ export default class ChessRules {
         }
       }
     });
-    Array.prototype.push.apply(moves, newMoves);
+    return moves.concat(newMoves);
   }
 
   // Generic method to find possible moves of "sliding or jumping" pieces
@@ -2404,7 +2420,11 @@ export default class ChessRules {
   }
 
   // What is the score ? (Interesting if game is over)
-  getCurrentScore(move) {
+  getCurrentScore(move_s) {
+    const move = move_s[move_s.length - 1];
+    // Shortcut in case the score was computed before:
+    if (move.result)
+      return move.result;
     const color = this.turn;
     const oppCol = C.GetOppCol(color);
     const kingPos = {
@@ -2461,7 +2481,7 @@ export default class ChessRules {
     this.computeNextMove(move);
     this.play(move);
     const newTurn = this.turn;
-    if (this.moveStack.length == 1)
+    if (this.moveStack.length == 1 && !this.hideMoves)
       this.playVisual(move, r);
     if (move.next) {
       this.gameState = {
@@ -2613,31 +2633,44 @@ export default class ChessRules {
     return 0; //nb of targets
   }
 
-  playReceivedMove(moves, callback) {
-    const launchAnimation = () => {
-      const r = container.querySelector(".chessboard").getBoundingClientRect();
-      const animateRec = i => {
-        this.animate(moves[i], () => {
-          this.play(moves[i]);
-          this.playVisual(moves[i], r);
-          if (i < moves.length - 1)
-            setTimeout(() => animateRec(i+1), 300);
-          else
-            callback();
-        });
-      };
-      animateRec(0);
+  launchAnimation(moves, container, callback) {
+    if (this.hideMoves) {
+      moves.forEach(m => this.play(m));
+      callback();
+      return;
+    }
+    const r = container.querySelector(".chessboard").getBoundingClientRect();
+    const animateRec = i => {
+      this.animate(moves[i], () => {
+        this.play(moves[i]);
+        this.playVisual(moves[i], r);
+        if (i < moves.length - 1)
+          setTimeout(() => animateRec(i+1), 300);
+        else
+          callback();
+      });
     };
+    animateRec(0);
+  }
+
+  playReceivedMove(moves, callback) {
     // Delay if user wasn't focused:
     const checkDisplayThenAnimate = (delay) => {
       if (container.style.display == "none") {
         alert("New move! Let's go back to game...");
         document.getElementById("gameInfos").style.display = "none";
         container.style.display = "block";
-        setTimeout(launchAnimation, 700);
+        setTimeout(
+          () => this.launchAnimation(moves, container, callback),
+          700
+        );
+      }
+      else {
+        setTimeout(
+          () => this.launchAnimation(moves, container, callback),
+          delay || 0
+        );
       }
-      else
-        setTimeout(launchAnimation, delay || 0);
     };
     let container = document.getElementById(this.containerId);
     if (document.hidden) {