X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fbase_rules.js;h=149bb4d22a1eabc5f05aec382c264b80647d822e;hb=a97bdbda4ecf83645d409b717e36828784d1450d;hp=da9fab7837622a1dc3fc46ce452da10538d88c66;hpb=1cd3e362caa05b60f01cf8b1d4f6bfeafc0be55f;p=vchess.git

diff --git a/client/src/base_rules.js b/client/src/base_rules.js
index da9fab78..149bb4d2 100644
--- a/client/src/base_rules.js
+++ b/client/src/base_rules.js
@@ -60,6 +60,14 @@ export const ChessRules = class ChessRules {
     return V.ShowMoves;
   }
 
+  // Some variants always show the same orientation
+  static get CanFlip() {
+    return true;
+  }
+  get canFlip() {
+    return V.CanFlip;
+  }
+
   // Turn "wb" into "B" (for FEN)
   static board2fen(b) {
     return b[0] == "w" ? b[1].toUpperCase() : b[1];
@@ -187,17 +195,19 @@ export const ChessRules = class ChessRules {
     }
     // Argument is a move:
     const move = moveOrSquare;
-    const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x];
+    const s = move.start,
+          e = move.end;
     // NOTE: next conditions are first for Atomic, and last for Checkered
     if (
       move.appear.length > 0 &&
-      Math.abs(sx - ex) == 2 &&
+      Math.abs(s.x - e.x) == 2 &&
+      s.y == e.y &&
       move.appear[0].p == V.PAWN &&
       ["w", "b"].includes(move.appear[0].c)
     ) {
       return {
-        x: (sx + ex) / 2,
-        y: sy
+        x: (s.x + e.x) / 2,
+        y: s.y
       };
     }
     return undefined; //default
@@ -274,12 +284,13 @@ export const ChessRules = class ChessRules {
       pieces[c][knight2Pos] = "n";
       pieces[c][rook2Pos] = "r";
     }
+    // Add turn + flags + enpassant
     return (
       pieces["b"].join("") +
       "/pppppppp/8/8/8/8/PPPPPPPP/" +
       pieces["w"].join("").toUpperCase() +
       " w 0 1111 -"
-    ); //add turn + flags + enpassant
+    );
   }
 
   // "Parse" FEN: just return untransformed string data
@@ -377,7 +388,6 @@ export const ChessRules = class ChessRules {
   setFlags(fenflags) {
     // white a-castle, h-castle, black a-castle, h-castle
     this.castleFlags = { w: [true, true], b: [true, true] };
-    if (!fenflags) return;
     for (let i = 0; i < 4; i++)
       this.castleFlags[i < 2 ? "w" : "b"][i % 2] = fenflags.charAt(i) == "1";
   }
@@ -459,7 +469,7 @@ export const ChessRules = class ChessRules {
     return { x: 8, y: 8 };
   }
 
-  // Color of thing on suqare (i,j). 'undefined' if square is empty
+  // Color of thing on square (i,j). 'undefined' if square is empty
   getColor(i, j) {
     return this.board[i][j].charAt(0);
   }
@@ -535,7 +545,7 @@ export const ChessRules = class ChessRules {
   ////////////////////
   // MOVES GENERATION
 
-  // All possible moves from selected square (assumption: color is OK)
+  // All possible moves from selected square
   getPotentialMovesFrom([x, y]) {
     switch (this.getPiece(x, y)) {
       case V.PAWN:
@@ -587,6 +597,7 @@ export const ChessRules = class ChessRules {
         })
       );
     }
+
     return mv;
   }
 
@@ -599,7 +610,7 @@ export const ChessRules = class ChessRules {
       let j = y + step[1];
       while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
         moves.push(this.getBasicMove([x, y], [i, j]));
-        if (oneStep !== undefined) continue outerLoop;
+        if (oneStep) continue outerLoop;
         i += step[0];
         j += step[1];
       }
@@ -626,8 +637,8 @@ export const ChessRules = class ChessRules {
         x + shiftX == lastRank
           ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]
           : [V.PAWN];
-      // One square forward
       if (this.board[x + shiftX][y] == V.EMPTY) {
+        // One square forward
         for (let piece of finalPieces) {
           moves.push(
             this.getBasicMove([x, y], [x + shiftX, y], {
@@ -825,12 +836,10 @@ export const ChessRules = class ChessRules {
   // (for engine and game end)
   getAllValidMoves() {
     const color = this.turn;
-    const oppCol = V.GetOppCol(color);
     let potentialMoves = [];
     for (let i = 0; i < V.size.x; i++) {
       for (let j = 0; j < V.size.y; j++) {
-        // Next condition "!= oppCol" to work with checkered variant
-        if (this.board[i][j] != V.EMPTY && this.getColor(i, j) != oppCol) {
+        if (this.getColor(i, j) == color) {
           Array.prototype.push.apply(
             potentialMoves,
             this.getPotentialMovesFrom([i, j])
@@ -844,10 +853,9 @@ export const ChessRules = class ChessRules {
   // Stop at the first move found
   atLeastOneMove() {
     const color = this.turn;
-    const oppCol = V.GetOppCol(color);
     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 && this.getColor(i, j) != oppCol) {
+        if (this.getColor(i, j) == color) {
           const moves = this.getPotentialMovesFrom([i, j]);
           if (moves.length > 0) {
             for (let k = 0; k < moves.length; k++) {
@@ -872,10 +880,31 @@ export const ChessRules = class ChessRules {
     );
   }
 
+  // Generic method for non-pawn pieces ("sliding or jumping"):
+  // is x,y attacked by a piece of color in array 'colors' ?
+  isAttackedBySlideNJump([x, y], colors, piece, steps, oneStep) {
+    for (let step of steps) {
+      let rx = x + step[0],
+          ry = y + step[1];
+      while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) {
+        rx += step[0];
+        ry += step[1];
+      }
+      if (
+        V.OnBoard(rx, ry) &&
+        this.getPiece(rx, ry) === piece &&
+        colors.includes(this.getColor(rx, ry))
+      ) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   // Is square x,y attacked by 'colors' pawns ?
   isAttackedByPawn([x, y], colors) {
     for (let c of colors) {
-      let pawnShift = c == "w" ? 1 : -1;
+      const pawnShift = c == "w" ? 1 : -1;
       if (x + pawnShift >= 0 && x + pawnShift < V.size.x) {
         for (let i of [-1, 1]) {
           if (
@@ -934,27 +963,6 @@ export const ChessRules = class ChessRules {
     );
   }
 
-  // Generic method for non-pawn pieces ("sliding or jumping"):
-  // is x,y attacked by a piece of color in array 'colors' ?
-  isAttackedBySlideNJump([x, y], colors, piece, steps, oneStep) {
-    for (let step of steps) {
-      let rx = x + step[0],
-          ry = y + step[1];
-      while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) {
-        rx += step[0];
-        ry += step[1];
-      }
-      if (
-        V.OnBoard(rx, ry) &&
-        this.getPiece(rx, ry) === piece &&
-        colors.includes(this.getColor(rx, ry))
-      ) {
-        return true;
-      }
-    }
-    return false;
-  }
-
   // Is color under check after his move ?
   underCheck(color) {
     return this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]);
@@ -1106,29 +1114,17 @@ export const ChessRules = class ChessRules {
     return 3;
   }
 
-  // NOTE: works also for extinction chess because depth is 3...
   getComputerMove() {
     const maxeval = V.INFINITY;
     const color = this.turn;
     // Some variants may show a bigger moves list to the human (Switching),
     // thus the argument "computer" below (which is generally ignored)
-    let moves1 = this.getAllValidMoves("computer");
+    let moves1 = this.getAllValidMoves();
+
     if (moves1.length == 0)
-      //TODO: this situation should not happen
+      // TODO: this situation should not happen
       return null;
 
-    // Can I mate in 1 ? (for Magnetic & Extinction)
-    for (let i of shuffle(ArrayFun.range(moves1.length))) {
-      this.play(moves1[i]);
-      let finish = Math.abs(this.evalPosition()) >= V.THRESHOLD_MATE;
-      if (!finish) {
-        const score = this.getCurrentScore();
-        if (["1-0", "0-1"].includes(score)) finish = true;
-      }
-      this.undo(moves1[i]);
-      if (finish) return moves1[i];
-    }
-
     // Rank moves using a min-max at depth 2
     for (let i = 0; i < moves1.length; i++) {
       // Initial self evaluation is very low: "I'm checkmated"
@@ -1140,7 +1136,7 @@ export const ChessRules = class ChessRules {
         // Initial enemy evaluation is very low too, for him
         eval2 = (color == "w" ? 1 : -1) * maxeval;
         // Second half-move:
-        let moves2 = this.getAllValidMoves("computer");
+        let moves2 = this.getAllValidMoves();
         for (let j = 0; j < moves2.length; j++) {
           this.play(moves2[j]);
           const score2 = this.getCurrentScore();
@@ -1176,6 +1172,7 @@ export const ChessRules = class ChessRules {
     moves1.sort((a, b) => {
       return (color == "w" ? 1 : -1) * (b.eval - a.eval);
     });
+//    console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
 
     let candidates = [0]; //indices of candidates moves
     for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++)
@@ -1201,7 +1198,7 @@ export const ChessRules = class ChessRules {
         return (color == "w" ? 1 : -1) * (b.eval - a.eval);
       });
     } else return currentBest;
-    //    console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
+//    console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
 
     candidates = [0];
     for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++)
@@ -1216,7 +1213,7 @@ export const ChessRules = class ChessRules {
     if (score != "*")
       return score == "1/2" ? 0 : (score == "1-0" ? 1 : -1) * maxeval;
     if (depth == 0) return this.evalPosition();
-    const moves = this.getAllValidMoves("computer");
+    const moves = this.getAllValidMoves();
     let v = color == "w" ? -maxeval : maxeval;
     if (color == "w") {
       for (let i = 0; i < moves.length; i++) {
@@ -1226,8 +1223,9 @@ export const ChessRules = class ChessRules {
         alpha = Math.max(alpha, v);
         if (alpha >= beta) break; //beta cutoff
       }
-    } //color=="b"
+    }
     else {
+      // color=="b"
       for (let i = 0; i < moves.length; i++) {
         this.play(moves[i]);
         v = Math.min(v, this.alphabeta(depth - 1, alpha, beta));