Update TODO

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

diff --git a/client/src/variants/Dynamo.js b/client/src/variants/Dynamo.js
index 53eedfd..9c0d080 100644 (file)
--- a/client/src/variants/Dynamo.js
+++ b/client/src/variants/Dynamo.js
@@ -9,7 +9,7 @@ export class DynamoRules extends ChessRules {
 
   canIplay(side, [x, y]) {
     // Sometimes opponent's pieces can be moved directly
-    return true;
+    return this.turn == side;
   }
 
   setOtherVariables(fen) {
@@ -88,7 +88,7 @@ export class DynamoRules extends ChessRules {
     return (
       ["appear","vanish"].map(
         mpart => {
-          if (mpart.length == 0) return "-";
+          if (this.amoves[L-1][mpart].length == 0) return "-";
           return (
             this.amoves[L-1][mpart].map(
               av => {
@@ -224,8 +224,21 @@ export class DynamoRules extends ChessRules {
         newMoves.forEach(m => { movesHash[getMoveHash(m)] = true; });
         Array.prototype.push.apply(moves, newMoves);
       };
-      // Free to play any move:
-      const moves = super.getPotentialMovesFrom([x, y])
+      // Free to play any move (if piece of my color):
+      let moves =
+        this.getColor(x, y) == color
+          ? super.getPotentialMovesFrom([x, y])
+          : [];
+      // There may be several suicide moves: keep only one
+      let hasExit = false;
+      moves = moves.filter(m => {
+        const suicide = (m.appear.length == 0);
+        if (suicide) {
+          if (hasExit) return false;
+          hasExit = true;
+        }
+        return true;
+      });
       const pawnShift = (color == 'w' ? -1 : 1);
       const pawnStartRank = (color == 'w' ? 6 : 1);
       // Structure to avoid adding moves twice (can be action & move)
@@ -256,7 +269,6 @@ export class DynamoRules extends ChessRules {
         ) {
           const deltaX = Math.abs(i - x);
           const deltaY = Math.abs(j - y);
-          // Can a priori go both ways, except with pawns
           switch (this.getPiece(i, j)) {
             case V.PAWN:
               if (
@@ -282,8 +294,8 @@ export class DynamoRules extends ChessRules {
               if (deltaX == deltaY) addMoves(step);
               break;
             case V.QUEEN:
-              if (deltaX == 0 || deltaY == 0 || deltaX == deltaY)
-                addMoves(step);
+              // All steps are valid for a queen:
+              addMoves(step);
               break;
             case V.KING:
               if (deltaX <= 1 && deltaY <= 1) addMoves(step, 1);
@@ -341,6 +353,45 @@ export class DynamoRules extends ChessRules {
     return [];
   }
 
+  getSlideNJumpMoves([x, y], steps, oneStep) {
+    let moves = [];
+    outerLoop: for (let step of steps) {
+      let i = x + step[0];
+      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) continue outerLoop;
+        i += step[0];
+        j += step[1];
+      }
+      if (V.OnBoard(i, j)) {
+        if (this.canTake([x, y], [i, j]))
+          moves.push(this.getBasicMove([x, y], [i, j]));
+      }
+      else {
+        // Add potential board exit (suicide), except for the king
+        const piece = this.getPiece(x, y);
+        if (piece != V.KING) {
+          const c = this.getColor(x, y);
+          moves.push({
+            start: { x: x, y: y},
+            end: { x: this.kingPos[c][0], y: this.kingPos[c][1] },
+            appear: [],
+            vanish: [
+              new PiPo({
+                x: x,
+                y: y,
+                c: c,
+                p: piece
+              })
+            ]
+          });
+        }
+      }
+    }
+    return moves;
+  }
+
   // Does m2 un-do m1 ? (to disallow undoing actions)
   oppositeMoves(m1, m2) {
     const isEqual = (av1, av2) => {
@@ -428,7 +479,19 @@ export class DynamoRules extends ChessRules {
         this.getPiece(rx, ry) == piece &&
         this.getColor(rx, ry) == color
       ) {
-        // Now step in the other direction: if end of the world, then attacked
+        // Continue some steps in the same direction (pull)
+        rx += step[0];
+        ry += 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)) return true;
+        // Step in the other direction (push)
         rx = x - step[0];
         ry = y - step[1];
         while (
@@ -464,6 +527,22 @@ export class DynamoRules extends ChessRules {
     return false;
   }
 
+  // No consideration of color: all pieces could be played
+  getAllPotentialMoves() {
+    let potentialMoves = [];
+    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) {
+          Array.prototype.push.apply(
+            potentialMoves,
+            this.getPotentialMovesFrom([i, j])
+          );
+        }
+      }
+    }
+    return potentialMoves;
+  }
+
   getCurrentScore() {
     if (this.subTurn == 2)
       // Move not over