Add Antiking v1

[vchess.git] / client / src / variants / Circular.js

diff --git a/client/src/variants/Circular.js b/client/src/variants/Circular.js
index d0abe1c..61997f2 100644 (file)
--- a/client/src/variants/Circular.js
+++ b/client/src/variants/Circular.js
@@ -3,6 +3,10 @@ import { ArrayFun } from "@/utils/array";
 import { randInt, shuffle } from "@/utils/alea";
 
 export const VariantRules = class CircularRules extends ChessRules {
+  static get HasCastle() {
+    return false;
+  }
+
   static get HasEnpassant() {
     return false;
   }
@@ -154,19 +158,10 @@ export const VariantRules = class CircularRules extends ChessRules {
     return moves;
   }
 
-  getPotentialKingMoves(sq) {
-    return this.getSlideNJumpMoves(
-      sq,
-      V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
-      "oneStep"
-    );
-  }
-
   filterValid(moves) {
     const filteredMoves = super.filterValid(moves);
     // If at least one full move made, everything is allowed:
-    if (this.movesCount >= 2)
-      return filteredMoves;
+    if (this.movesCount >= 2) return filteredMoves;
     // Else, forbid check:
     const oppCol = V.GetOppCol(this.turn);
     return filteredMoves.filter(m => {
@@ -177,25 +172,23 @@ export const VariantRules = class CircularRules extends ChessRules {
     });
   }
 
-  isAttackedByPawn([x, y], colors) {
-    const pawnShift = 1;
-    const attackerRow = V.ComputeX(x + pawnShift);
-    for (let c of colors) {
-      for (let i of [-1, 1]) {
-        if (
-          y + i >= 0 &&
-          y + i < V.size.y &&
-          this.getPiece(attackerRow, y + i) == V.PAWN &&
-          this.getColor(attackerRow, y + i) == c
-        ) {
-          return true;
-        }
+  isAttackedByPawn([x, y], color) {
+    // pawn shift is always 1 (all pawns go the same way)
+    const attackerRow = V.ComputeX(x + 1);
+    for (let i of [-1, 1]) {
+      if (
+        y + i >= 0 &&
+        y + i < V.size.y &&
+        this.getPiece(attackerRow, y + i) == V.PAWN &&
+        this.getColor(attackerRow, y + i) == color
+      ) {
+        return true;
       }
     }
     return false;
   }
 
-  isAttackedBySlideNJump([x, y], colors, piece, steps, oneStep) {
+  isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) {
     for (let step of steps) {
       let rx = V.ComputeX(x + step[0]),
           ry = y + step[1];
@@ -205,8 +198,8 @@ export const VariantRules = class CircularRules extends ChessRules {
       }
       if (
         V.OnBoard(rx, ry) &&
-        this.getPiece(rx, ry) === piece &&
-        colors.includes(this.getColor(rx, ry))
+        this.getPiece(rx, ry) == piece &&
+        this.getColor(rx, ry) == color
       ) {
         return true;
       }
@@ -223,15 +216,11 @@ export const VariantRules = class CircularRules extends ChessRules {
     return flags;
   }
 
-  updateVariables(move) {
+  postPlay(move) {
+    super.postPlay(move);
     const c = move.vanish[0].c;
-    const secondRank = {"w":6, "b":2};
-    // Update king position + flags
-    if (move.vanish[0].p == V.KING && move.appear.length > 0) {
-      this.kingPos[c][0] = move.appear[0].x;
-      this.kingPos[c][1] = move.appear[0].y;
-    }
-    else if (move.vanish[0].p == V.PAWN && secondRank[c] == move.start.x)
+    const secondRank = { "w": 6, "b": 2 };
+    if (move.vanish[0].p == V.PAWN && secondRank[c] == move.start.x)
       // This move turns off a 2-squares pawn flag
       this.pawnFlags[c][move.start.y] = false;
   }
@@ -246,4 +235,8 @@ export const VariantRules = class CircularRules extends ChessRules {
       k: 1000
     };
   }
+
+  static get SEARCH_DEPTH() {
+    return 2;
+  }
 };