X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FAtomic.js;h=831fb2f239d7f8912c0937296ec1a25d634d43a3;hb=10cceb25109739fa39b9b968be2707dee1d25a07;hp=19521c2d3c57f774361064dd7a15cc28d9051d64;hpb=68e19a449db7a12e0a168e99cd750d985c983ba1;p=vchess.git

diff --git a/client/src/variants/Atomic.js b/client/src/variants/Atomic.js
index 19521c2d..831fb2f2 100644
--- a/client/src/variants/Atomic.js
+++ b/client/src/variants/Atomic.js
@@ -1,16 +1,108 @@
-import { ChessRules, PiPo } from "@/base_rules";
+import { ChessRules, Move, PiPo } from "@/base_rules";
 
-export const VariantRules = class AtomicRules extends ChessRules {
-  getEpSquare(moveOrSquare) {
-    if (typeof moveOrSquare !== "object" || moveOrSquare.appear.length > 0)
-      return super.getEpSquare(moveOrSquare);
-    // Capturing move: no en-passant
-    return undefined;
+export class AtomicRules extends ChessRules {
+
+  static get Options() {
+    return {
+      check: [
+        {
+          label: "Balanced",
+          defaut: false,
+          variable: "balanced"
+        }
+      ],
+      select: ChessRules.Options.select
+    };
+  }
+
+  static AbbreviateOptions(opts) {
+    return opts["balanced"] ? 'B' : '';
+  }
+
+  static GenRandInitFen(options) {
+    return ChessRules.GenRandInitFen(options) + (options.balanced ? " B" : "");
+  }
+
+  setOtherVariables(fen) {
+    super.setOtherVariables(fen);
+    this.balanced = !!V.ParseFen(fen).balanced;
+  }
+
+  static ParseFen(fen) {
+    return Object.assign(
+      { balanced: fen.split(" ")[5] },
+      ChessRules.ParseFen(fen)
+    );
+  }
+
+  static IsGoodFen(fen) {
+    if (!ChessRules.IsGoodFen(fen)) return false;
+    const balanced = V.ParseFen(fen).balanced;
+    return (!balanced || balanced == 'B');
+  }
+
+  getFen() {
+    return super.getFen() + (this.balanced ? " B" : "");
+  }
+
+  hoverHighlight([x, y]) {
+    return this.balanced && this.movesCount == 0 && [1, 6].includes(x);
+  }
+
+  canIplay(side, [x, y]) {
+    if (this.balanced && this.movesCount == 0)
+      return (this.turn == side && this.getPiece(x, y) == V.PAWN);
+    return super.canIplay(side, [x, y]);
+  }
+
+  doClick(square) {
+    if (!this.balanced || this.movesCount >= 1) return null;
+    const [x, y] = [square[0], square[1]];
+    if (![1, 6].includes(x)) return null;
+    return new Move({
+      appear: [],
+      vanish: [
+        new PiPo({
+          x: x,
+          y: y,
+          c: this.getColor(x, y),
+          p: V.PAWN
+        })
+      ],
+      start: { x: x, y: y },
+      end: { x: x, y: y }
+    });
   }
 
   getPotentialMovesFrom([x, y]) {
-    let moves = super.getPotentialMovesFrom([x, y]);
+    if (this.balanced && this.movesCount == 0) {
+      if ([1, 6].includes(x)) {
+        const c = this.getColor(x, y);
+        return [
+          new Move({
+            appear: [],
+            vanish: [
+              new PiPo({ x: x, y: y, p: V.PAWN, c: c })
+            ],
+            start: { x: x, y: y },
+            end: { x: x, y: y }
+          })
+        ];
+      }
+      return [];
+    }
 
+    let moves = super.getPotentialMovesFrom([x, y]);
+    if (this.getPiece(x, y) == V.PAWN) {
+      // Promotions by captures can be reduced to only one deterministic
+      // move (because of the explosion).
+      moves = moves.filter(m => {
+        return (
+          m.vanish.length == 1 ||
+          [V.PAWN, V.QUEEN].includes(m.appear[0].p)
+        );
+      });
+    }
     // Handle explosions
     moves.forEach(m => {
       // NOTE: if vanish.length==2 and appear.length==2, this is castle
@@ -48,7 +140,6 @@ export const VariantRules = class AtomicRules extends ChessRules {
         m.appear.pop(); //Nothin appears in this case
       }
     });
-
     return moves;
   }
 
@@ -85,7 +176,8 @@ export const VariantRules = class AtomicRules extends ChessRules {
 
   postPlay(move) {
     super.postPlay(move);
-    if (move.appear.length == 0) {
+    // NOTE: (harmless) condition on movesCount for Atomic2
+    if (move.appear.length == 0 && this.movesCount >= 2) {
       // Capture
       const firstRank = { w: 7, b: 0 };
       for (let c of ["w", "b"]) {
@@ -96,7 +188,8 @@ export const VariantRules = class AtomicRules extends ChessRules {
         ) {
           this.kingPos[c] = [-1, -1];
           this.castleFlags[c] = [8, 8];
-        } else {
+        }
+        else {
           // Now check if init rook(s) exploded
           if (Math.abs(move.end.x - firstRank[c]) <= 1) {
             if (Math.abs(move.end.y - this.castleFlags[c][0]) <= 1)
@@ -113,7 +206,11 @@ export const VariantRules = class AtomicRules extends ChessRules {
     super.postUndo(move);
     const c = this.turn;
     const oppCol = V.GetOppCol(c);
-    if ([this.kingPos[c][0], this.kingPos[oppCol][0]].some(e => e < 0)) {
+    // NOTE: condition on movesCount for balanced setting
+    if (
+      this.movesCount >= 1 &&
+      [this.kingPos[c][0], this.kingPos[oppCol][0]].some(e => e < 0)
+    ) {
       // There is a chance that last move blowed some king away..
       for (let psq of move.vanish) {
         if (psq.p == "k")
@@ -134,7 +231,8 @@ export const VariantRules = class AtomicRules extends ChessRules {
     return res;
   }
 
-  getCheckSquares(color) {
+  getCheckSquares() {
+    const color = this.turn;
     let res = [];
     if (
       this.kingPos[color][0] >= 0 && //king might have exploded
@@ -151,9 +249,16 @@ export const VariantRules = class AtomicRules extends ChessRules {
     if (kp[0] < 0)
       // King disappeared
       return color == "w" ? "0-1" : "1-0";
-    if (this.atLeastOneMove())
-      return "*";
+    if (this.atLeastOneMove()) return "*";
     if (!this.isAttacked(kp, V.GetOppCol(color))) return "1/2";
     return color == "w" ? "0-1" : "1-0"; //checkmate
   }
+
+  getNotation(move) {
+    if (move.appear.length == 0 && move.vanish.length == 1)
+      // First move in game (balanced == true)
+      return V.CoordsToSquare(move.start) + "X";
+    return super.getNotation(move);
+  }
+
 };