X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FShogi.js;h=6c522dc6f8cddfd7a8def4aa8a4e5d78789f5add;hb=c3ff3a0c807d97c0311a06491318fe02440266db;hp=082d93917c85a438fc271b736a57066b3063aa9c;hpb=e2f204eda8630746cb951889da01241b1e5f5733;p=vchess.git

diff --git a/client/src/variants/Shogi.js b/client/src/variants/Shogi.js
index 082d9391..6c522dc6 100644
--- a/client/src/variants/Shogi.js
+++ b/client/src/variants/Shogi.js
@@ -1,6 +1,6 @@
 import { ChessRules, PiPo, Move } from "@/base_rules";
 import { ArrayFun } from "@/utils/array";
-import { shuffle } from "@/utils/alea";
+import { sample, shuffle } from "@/utils/alea";
 
 export class ShogiRules extends ChessRules {
   static get HasFlags() {
@@ -11,6 +11,14 @@ export class ShogiRules extends ChessRules {
     return false;
   }
 
+  static get Monochrome() {
+    return true;
+  }
+
+  static get Notoodark() {
+    return true;
+  }
+
   static IsGoodFen(fen) {
     if (!ChessRules.IsGoodFen(fen)) return false;
     const fenParsed = V.ParseFen(fen);
@@ -102,20 +110,49 @@ export class ShogiRules extends ChessRules {
         "w 0 00000000000000"
       );
     }
-    let pieces = { w: new Array(9), b: new Array(9) };
+    // Randomization following these indications:
+    // http://www.shogi.net/shogi-l/Archive/2007/Nmar16-02.txt
+    let pieces1 = { w: new Array(4), b: new Array(4) };
+    let positions2 = { w: new Array(2), b: new Array(2) };
     for (let c of ["w", "b"]) {
       if (c == 'b' && randomness == 1) {
-        pieces['b'] = pieces['w'];
+        pieces1['b'] = JSON.parse(JSON.stringify(pieces1['w'])).reverse();
+        positions2['b'] =
+          JSON.parse(JSON.stringify(positions2['w'])).reverse()
+          .map(p => 8 - p);
         break;
       }
-      let positions = shuffle(ArrayFun.range(9));
-      const composition = ['l', 'l', 'n', 'n', 's', 's', 'g', 'g', 'k'];
-      for (let i = 0; i < 9; i++) pieces[c][positions[i]] = composition[i];
+      let positions = shuffle(ArrayFun.range(4));
+      const composition = ['s', 's', 'g', 'g'];
+      for (let i = 0; i < 4; i++) pieces1[c][positions[i]] = composition[i];
+      positions2[c] = sample(ArrayFun.range(9), 2).sort();
     }
     return (
-      pieces["b"].join("") +
-      "/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/" +
-      pieces["w"].join("").toUpperCase() +
+      (
+        "ln" +
+        pieces1["b"].slice(0, 2).join("") +
+        "k" +
+        pieces1["b"].slice(2, 4).join("") +
+        "nl/"
+      ) +
+      (
+        (positions2['b'][0] || "") + 'r' +
+        (positions2['b'][1] - positions2['b'][0] - 1 || "") + 'b' +
+        (8 - positions2['b'][1] || "")
+      ) +
+      "/ppppppppp/9/9/9/PPPPPPPPP/" +
+      (
+        (positions2['w'][0] || "") + 'B' +
+        (positions2['w'][1] - positions2['w'][0] - 1 || "") + 'R' +
+        (8 - positions2['w'][1] || "")
+      ) +
+      (
+        "/LN" +
+        pieces1["w"].slice(0, 2).join("").toUpperCase() +
+        "K" +
+        pieces1["w"].slice(2, 4).join("").toUpperCase() +
+        "NL"
+      ) +
       " w 0 00000000000000"
     );
   }
@@ -139,26 +176,27 @@ export class ShogiRules extends ChessRules {
 
   setOtherVariables(fen) {
     super.setOtherVariables(fen);
-    const fenParsed = V.ParseFen(fen);
     // Also init reserves (used by the interface to show landable pieces)
+    const reserve =
+      V.ParseFen(fen).reserve.split("").map(x => parseInt(x, 10));
     this.reserve = {
       w: {
-        [V.PAWN]: parseInt(fenParsed.reserve[0]),
-        [V.ROOK]: parseInt(fenParsed.reserve[1]),
-        [V.BISHOP]: parseInt(fenParsed.reserve[2]),
-        [V.GOLD_G]: parseInt(fenParsed.reserve[3]),
-        [V.SILVER_G]: parseInt(fenParsed.reserve[4]),
-        [V.KNIGHT]: parseInt(fenParsed.reserve[5]),
-        [V.LANCE]: parseInt(fenParsed.reserve[6])
+        [V.PAWN]: reserve[0],
+        [V.ROOK]: reserve[1],
+        [V.BISHOP]: reserve[2],
+        [V.GOLD_G]: reserve[3],
+        [V.SILVER_G]: reserve[4],
+        [V.KNIGHT]: reserve[5],
+        [V.LANCE]: reserve[6]
       },
       b: {
-        [V.PAWN]: parseInt(fenParsed.reserve[7]),
-        [V.ROOK]: parseInt(fenParsed.reserve[8]),
-        [V.BISHOP]: parseInt(fenParsed.reserve[9]),
-        [V.GOLD_G]: parseInt(fenParsed.reserve[10]),
-        [V.SILVER_G]: parseInt(fenParsed.reserve[11]),
-        [V.KNIGHT]: parseInt(fenParsed.reserve[12]),
-        [V.LANCE]: parseInt(fenParsed.reserve[13])
+        [V.PAWN]: reserve[7],
+        [V.ROOK]: reserve[8],
+        [V.BISHOP]: reserve[9],
+        [V.GOLD_G]: reserve[10],
+        [V.SILVER_G]: reserve[11],
+        [V.KNIGHT]: reserve[12],
+        [V.LANCE]: reserve[13]
       }
     };
   }
@@ -372,6 +410,18 @@ export class ShogiRules extends ChessRules {
     );
   }
 
+  getPotentialLanceMoves(sq) {
+    const forward = (this.turn == 'w' ? -1 : 1);
+    return this.getSlideNJumpMoves(
+      sq,
+      [[forward, 0]],
+      {
+        promote: V.P_LANCE,
+        force: true
+      }
+    );
+  }
+
   getPotentialRookMoves(sq) {
     return this.getSlideNJumpMoves(
       sq, V.steps[V.ROOK], { promote: V.P_ROOK });
@@ -382,12 +432,6 @@ export class ShogiRules extends ChessRules {
       sq, V.steps[V.BISHOP], { promote: V.P_BISHOP });
   }
 
-  getPotentialLanceMoves(sq) {
-    const forward = (this.turn == 'w' ? -1 : 1);
-    return this.getSlideNJumpMoves(
-      sq, [[forward, 0]], { promote: V.P_LANCE });
-  }
-
   getPotentialDragonMoves(sq) {
     return (
       this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(