X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fbase_rules.js;h=e6fd6d73908e3e3250eaa6674e2ec2e6b31383b2;hb=e71161fbfffe53b0f4b174e0467cdd98cc70b7b0;hp=5ebe4997741d88d2fb70f8db8825c103618b8505;hpb=20620465247585ed4e845885c4d9fee8cd6920c1;p=vchess.git

diff --git a/client/src/base_rules.js b/client/src/base_rules.js
index 5ebe4997..e6fd6d73 100644
--- a/client/src/base_rules.js
+++ b/client/src/base_rules.js
@@ -43,19 +43,29 @@ export const ChessRules = class ChessRules {
   }
 
   // Some variants cannot have analyse mode
-  static get CanAnalyse() {
+  static get CanAnalyze() {
     return true;
   }
+  // Patch: issues with javascript OOP, objects can't access static fields.
+  get canAnalyze() {
+    return V.CanAnalyze;
+  }
 
   // Some variants show incomplete information,
   // and thus show only a partial moves list or no list at all.
   static get ShowMoves() {
     return "all";
   }
+  get showMoves() {
+    return V.ShowMoves;
+  }
 
-  // Path to pieces
-  static getPpath(b) {
-    return b; //usual pieces in pieces/ folder
+  // Some variants always show the same orientation
+  static get CanFlip() {
+    return true;
+  }
+  get canFlip() {
+    return V.CanFlip;
   }
 
   // Turn "wb" into "B" (for FEN)
@@ -96,9 +106,12 @@ export const ChessRules = class ChessRules {
     if (position.length == 0) return false;
     const rows = position.split("/");
     if (rows.length != V.size.x) return false;
+    let kings = {};
     for (let row of rows) {
       let sumElts = 0;
       for (let i = 0; i < row.length; i++) {
+        if (['K','k'].includes(row[i]))
+          kings[row[i]] = true;
         if (V.PIECES.includes(row[i].toLowerCase())) sumElts++;
         else {
           const num = parseInt(row[i]);
@@ -108,6 +121,9 @@ export const ChessRules = class ChessRules {
       }
       if (sumElts != V.size.y) return false;
     }
+    // Both kings should be on board:
+    if (Object.keys(kings).length != 2)
+      return false;
     return true;
   }
 
@@ -154,6 +170,11 @@ export const ChessRules = class ChessRules {
     return V.CoordToColumn(coords.y) + (V.size.x - coords.x);
   }
 
+  // Path to pieces
+  getPpath(b) {
+    return b; //usual pieces in pieces/ folder
+  }
+
   // Aggregates flags into one object
   aggregateFlags() {
     return this.castleFlags;
@@ -174,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
@@ -261,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
@@ -351,9 +375,9 @@ export const ChessRules = class ChessRules {
       for (let indexInRow = 0; indexInRow < rows[i].length; indexInRow++) {
         const character = rows[i][indexInRow];
         const num = parseInt(character);
+        // If num is a number, just shift j:
         if (!isNaN(num)) j += num;
-        //just shift j
-        //something at position i,j
+        // Else: something at position i,j
         else board[i][j++] = V.fen2board(character);
       }
     }
@@ -364,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";
   }
@@ -373,7 +396,9 @@ export const ChessRules = class ChessRules {
   // INITIALIZATION
 
   constructor(fen) {
-    this.re_init(fen);
+    // In printDiagram() fen isn't supply because only getPpath() is used
+    if (fen)
+      this.re_init(fen);
   }
 
   // Fen string fully describes the game state
@@ -429,7 +454,7 @@ export const ChessRules = class ChessRules {
     if (V.HasEnpassant) {
       const epSq =
         parsedFen.enpassant != "-"
-          ? V.SquareToCoords(parsedFen.enpassant)
+          ? this.getEpSquare(parsedFen.enpassant)
           : undefined;
       this.epSquares = [epSq];
     }
@@ -444,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);
   }
@@ -520,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:
@@ -572,6 +597,7 @@ export const ChessRules = class ChessRules {
         })
       );
     }
+
     return mv;
   }
 
@@ -611,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], {
@@ -716,10 +742,11 @@ export const ChessRules = class ChessRules {
     const oppCol = V.GetOppCol(c);
     let moves = [];
     let i = 0;
+    // King, then rook:
     const finalSquares = [
       [2, 3],
       [V.size.y - 2, V.size.y - 3]
-    ]; //king, then rook
+    ];
     castlingCheck: for (
       let castleSide = 0;
       castleSide < 2;
@@ -961,6 +988,8 @@ export const ChessRules = class ChessRules {
   // After move is played, update variables + flags
   updateVariables(move) {
     let piece = undefined;
+    // TODO: update variables before move is played, and just use this.turn ?
+    // (doesn't work in general, think MarseilleChess)
     let c = undefined;
     if (move.vanish.length >= 1) {
       // Usual case, something is moved
@@ -971,9 +1000,8 @@ export const ChessRules = class ChessRules {
       piece = move.appear[0].p;
       c = move.appear[0].c;
     }
-    if (c == "c") {
-      //if (!["w","b"].includes(c))
-      // 'c = move.vanish[0].c' doesn't work for Checkered
+    if (!['w','b'].includes(c)) {
+      // Checkered, for example
       c = V.GetOppCol(this.turn);
     }
     const firstRank = c == "w" ? V.size.x - 1 : 0;
@@ -1016,9 +1044,9 @@ export const ChessRules = class ChessRules {
 
   play(move) {
     // DEBUG:
-    //    if (!this.states) this.states = [];
-    //    const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
-    //    this.states.push(stateFen);
+//    if (!this.states) this.states = [];
+//    const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
+//    this.states.push(stateFen);
 
     if (V.HasFlags) move.flags = JSON.stringify(this.aggregateFlags()); //save flags (for undo)
     if (V.HasEnpassant) this.epSquares.push(this.getEpSquare(move));
@@ -1037,9 +1065,9 @@ export const ChessRules = class ChessRules {
     this.unupdateVariables(move);
 
     // DEBUG:
-    //    const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
-    //    if (stateFen != this.states[this.states.length-1]) debugger;
-    //    this.states.pop();
+//    const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
+//    if (stateFen != this.states[this.states.length-1]) debugger;
+//    this.states.pop();
   }
 
   ///////////////
@@ -1048,7 +1076,6 @@ export const ChessRules = class ChessRules {
   // What is the score ? (Interesting if game is over)
   getCurrentScore() {
     if (this.atLeastOneMove())
-      // game not over
       return "*";
 
     // Game over
@@ -1097,8 +1124,9 @@ export const ChessRules = class ChessRules {
     // 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");
+
     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)
@@ -1185,7 +1213,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++)
@@ -1210,8 +1238,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));
@@ -1245,7 +1274,7 @@ export const ChessRules = class ChessRules {
   // TODO: un-ambiguous notation (switch on piece type, check directions...)
   getNotation(move) {
     if (move.appear.length == 2 && move.appear[0].p == V.KING)
-      //castle
+      // Castle
       return move.end.y < move.start.y ? "0-0-0" : "0-0";
 
     // Translate final square
@@ -1259,10 +1288,10 @@ export const ChessRules = class ChessRules {
         // Capture
         const startColumn = V.CoordToColumn(move.start.y);
         notation = startColumn + "x" + finalSquare;
-      } //no capture
+      }
       else notation = finalSquare;
       if (move.appear.length > 0 && move.appear[0].p != V.PAWN)
-        //promotion
+        // Promotion
         notation += "=" + move.appear[0].p.toUpperCase();
       return notation;
     }