X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FSuction.js;h=9ac5b4424a4df2f6ca70cd703ec5aa1592204dec;hb=3a2a7b5fd3c6bfd0752838094c27e1fb6172d109;hp=bfb9fa00951862e8625e25296ca320e9130758f3;hpb=31e9e40ad45faba38612982cfb1d6bdfd98ae20f;p=vchess.git

diff --git a/client/src/variants/Suction.js b/client/src/variants/Suction.js
index bfb9fa00..9ac5b442 100644
--- a/client/src/variants/Suction.js
+++ b/client/src/variants/Suction.js
@@ -1,6 +1,48 @@
 import { ChessRules, PiPo, Move } from "@/base_rules";
 
-export const VariantRules = class AntimatterRules extends ChessRules {
+export const VariantRules = class SuctionRules extends ChessRules {
+  static get HasFlags() {
+    return false;
+  }
+
+  setOtherVariables(fen) {
+
+console.log(fen);
+
+    super.setOtherVariables(fen);
+    // Local stack of "captures"
+    this.cmoves = [];
+    const cmove = V.ParseFen(fen).cmove;
+    if (cmove == "-") this.cmoves.push(null);
+    else {
+      this.cmoves.push({
+        start: ChessRules.SquareToCoords(cmove.substr(0, 2)),
+        end: ChessRules.SquareToCoords(cmove.substr(2))
+      });
+    }
+  }
+
+  static ParseFen(fen) {
+    return Object.assign({}, ChessRules.ParseFen(fen), {
+      cmove: fen.split(" ")[4]
+    });
+  }
+
+  static IsGoodFen(fen) {
+    if (!ChessRules.IsGoodFen(fen)) return false;
+    const fenParts = fen.split(" ");
+    if (fenParts.length != 6) return false;
+    if (fenParts[5] != "-" && !fenParts[5].match(/^([a-h][1-8]){2}$/))
+      return false;
+    return true;
+  }
+
+  getCmove(move) {
+    if (move.vanish.length == 2)
+      return { start: move.start, end: move.end };
+    return null;
+  }
+
   getBasicMove([sx, sy], [ex, ey]) {
     const startColor = this.getColor(sx, sy);
     const startPiece = this.getPiece(sx, sy);
@@ -121,32 +163,64 @@ export const VariantRules = class AntimatterRules extends ChessRules {
     return [];
   }
 
-  updateVariables(move) {
-    super.updateVariables(move);
+  // Does m2 un-do m1 ? (to disallow undoing captures)
+  oppositeMoves(m1, m2) {
+    return (
+      m1 &&
+      m2.vanish.length == 2 &&
+      m1.start.x == m2.start.x &&
+      m1.end.x == m2.end.x &&
+      m1.start.y == m2.start.y &&
+      m1.end.y == m2.end.y
+    );
+  }
+
+  filterValid(moves) {
+    if (moves.length == 0) return [];
+    const color = this.turn;
+    return moves.filter(m => {
+      const L = this.cmoves.length; //at least 1: init from FEN
+      return !this.oppositeMoves(this.cmoves[L - 1], m);
+    });
+  }
+
+  static GenRandInitFen(randomness) {
+    // Add empty cmove:
+    return ChessRules.GenRandInitFen(randomness).slice(0, -6) + "- -";
+  }
+
+  getFen() {
+    const L = this.cmoves.length;
+    const cmoveFen = !this.cmoves[L - 1]
+      ? "-"
+      : ChessRules.CoordsToSquare(this.cmoves[L - 1].start) +
+        ChessRules.CoordsToSquare(this.cmoves[L - 1].end);
+    return super.getFen() + " " + cmoveFen;
+  }
+
+  postPlay(move) {
+    super.postPlay(move);
     if (move.vanish.length == 2) {
       // Was opponent king swapped?
       if (move.vanish[1].p == V.KING)
         this.kingPos[this.turn] = [move.appear[1].x, move.appear[1].y];
     }
+    this.cmoves.push(this.getCmove(move));
   }
 
-  unupdateVariables(move) {
-    super.unupdateVariables(move);
+  postUndo(move) {
+    super.postUndo(move);
     if (move.appear.length == 2) {
-      // Was opponent king swapped?
       if (move.appear[1].p == V.KING)
-        this.kingPos[move.vanish[1].c] = [move.vanish[1].x,move.vanish[1].y];
+        this.kingPos[move.vanish[1].c] = [move.vanish[1].x, move.vanish[1].y];
     }
+    this.cmoves.pop();
   }
 
   atLeastOneMove() {
     return true;
   }
 
-  filterValid(moves) {
-    return moves;
-  }
-
   getCheckSquares() {
     return [];
   }
@@ -166,4 +240,28 @@ export const VariantRules = class AntimatterRules extends ChessRules {
     // Very simple criterion for now: kings position
     return this.kingPos["w"][0] + this.kingPos["b"][0];
   }
+
+  getNotation(move) {
+    // Translate final square
+    const finalSquare = V.CoordsToSquare(move.end);
+
+    const piece = this.getPiece(move.start.x, move.start.y);
+    if (piece == V.PAWN) {
+      // Pawn move
+      let notation = "";
+      if (move.vanish.length == 2) {
+        // Capture
+        const startColumn = V.CoordToColumn(move.start.y);
+        notation = startColumn + "x" + finalSquare;
+      }
+      else notation = finalSquare;
+      return notation;
+    }
+    // Piece movement
+    return (
+      piece.toUpperCase() +
+      (move.vanish.length == 2 ? "x" : "") +
+      finalSquare
+    );
+  }
 };