Fix Eightpieces, add some simple variants, add a basic variants classification instea...

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

diff --git a/client/src/variants/Dark.js b/client/src/variants/Dark.js
index 3944ca1..65934e6 100644 (file)
--- a/client/src/variants/Dark.js
+++ b/client/src/variants/Dark.js
@@ -2,7 +2,7 @@ import { ChessRules } from "@/base_rules";
 import { ArrayFun } from "@/utils/array";
 import { randInt } from "@/utils/alea";
 
-export const VariantRules = class DarkRules extends ChessRules {
+export class DarkRules extends ChessRules {
   // Analyse in Dark mode makes no sense
   static get CanAnalyze() {
     return false;
@@ -13,6 +13,10 @@ export const VariantRules = class DarkRules extends ChessRules {
     return "none";
   }
 
+  static get SomeHiddenMoves() {
+    return true;
+  }
+
   setOtherVariables(fen) {
     super.setOtherVariables(fen);
     const [sizeX, sizeY] = [V.size.x, V.size.y];
@@ -37,16 +41,16 @@ export const VariantRules = class DarkRules extends ChessRules {
     for (let i = 0; i < V.size.x; i++) {
       for (let j = 0; j < V.size.y; j++) {
         if (this.board[i][j] != V.EMPTY) {
-          const color = this.getColor(i, j);
-          this.enlightened[color][i][j] = true;
+          const c = this.getColor(i, j);
+          this.enlightened[c][i][j] = true;
           // Add potential squares visible by "impossible pawn capture"
           if (this.getPiece(i, j) == V.PAWN) {
             for (let shiftY of [-1, 1]) {
               if (
-                V.OnBoard(i + pawnShift[color], j + shiftY) &&
-                this.board[i + pawnShift[color]][j + shiftY] == V.EMPTY
+                V.OnBoard(i + pawnShift[c], j + shiftY) &&
+                this.board[i + pawnShift[c]][j + shiftY] == V.EMPTY
               ) {
-                this.enlightened[color][i + pawnShift[color]][j + shiftY] = true;
+                this.enlightened[c][i + pawnShift[c]][j + shiftY] = true;
               }
             }
           }
@@ -63,6 +67,24 @@ export const VariantRules = class DarkRules extends ChessRules {
       this.enlightened["w"][move.end.x][move.end.y] = true;
     for (let move of movesBlack)
       this.enlightened["b"][move.end.x][move.end.y] = true;
+    // Include en-passant capturing square if any:
+    let moves = currentTurn == "w" ? movesWhite : movesBlack;
+    for (let m of moves) {
+      if (
+        m.appear[0].p == V.PAWN &&
+        m.vanish.length == 2 &&
+        m.vanish[1].x != m.end.x
+      ) {
+        const psq = m.vanish[1];
+        this.enlightened[currentTurn][psq.x][psq.y] = true;
+        break;
+      }
+    }
+  }
+
+  filterValid(moves) {
+    // Used in the interface
+    return moves;
   }
 
   // Has to be redefined to avoid an infinite loop
@@ -85,9 +107,9 @@ export const VariantRules = class DarkRules extends ChessRules {
     return [];
   }
 
-  updateVariables(move) {
-    super.updateVariables(move);
-    if (move.vanish.length >= 2 && move.vanish[1].p == V.KING)
+  postPlay(move) {
+    super.postPlay(move);
+    if (move.vanish.length == 2 && move.vanish[1].p == V.KING)
       // We took opponent king (because if castle vanish[1] is a rook)
       this.kingPos[this.turn] = [-1, -1];
 
@@ -95,13 +117,11 @@ export const VariantRules = class DarkRules extends ChessRules {
     this.updateEnlightened();
   }
 
-  unupdateVariables(move) {
-    super.unupdateVariables(move);
-    const c = move.vanish[0].c;
-    const oppCol = V.GetOppCol(c);
-    if (this.kingPos[oppCol][0] < 0)
+  postUndo(move) {
+    super.postUndo(move);
+    if (move.vanish.length == 2 && move.vanish[1].p == V.KING)
       // Last move took opponent's king:
-      this.kingPos[oppCol] = [move.vanish[1].x, move.vanish[1].y];
+      this.kingPos[move.vanish[1].c] = [move.vanish[1].x, move.vanish[1].y];
 
     // Update lights for both colors:
     this.updateEnlightened();
@@ -223,19 +243,19 @@ export const VariantRules = class DarkRules extends ChessRules {
 
       // Can I take something ? If yes, do it if it seems good...
       if (move.vanish.length == 2 && move.vanish[1].c != color) {
-        //avoid castle
+        // OK this isn't a castling move
         const myPieceVal = V.VALUES[move.appear[0].p];
         const hisPieceVal = V.VALUES[move.vanish[1].p];
-        if (myPieceVal <= hisPieceVal) move.eval = hisPieceVal - myPieceVal + 2;
-        //favor captures
+        // Favor captures
+        if (myPieceVal <= hisPieceVal)
+          move.eval = hisPieceVal - myPieceVal + 1;
         else {
           // Taking a pawn with minor piece,
           // or minor piece or pawn with a rook,
           // or anything but a queen with a queen,
           // or anything with a king.
-          // ==> Do it at random, although
-          //     this is clearly inferior to what a human can deduce...
-          move.eval = Math.random() < 0.5 ? 1 : -1;
+          move.eval = hisPieceVal - myPieceVal;
+                      //Math.random() < 0.5 ? 1 : -1;
         }
       }
     }