From: Benjamin Auder <benjamin.auder@somewhere>
Date: Thu, 3 Dec 2020 22:27:25 +0000 (+0100)
Subject: Draft Fullcavalry and Atomic2 (pawn removal). Fix Grand
X-Git-Url: https://git.auder.net/doc/html/css/scripts/%24%7BgetWhatsApp%28link%29%7D?a=commitdiff_plain;h=0fb43db7c2858201e8410670b90f95ad8b138964;p=vchess.git

Draft Fullcavalry and Atomic2 (pawn removal). Fix Grand
---

diff --git a/client/src/translations/en.js b/client/src/translations/en.js
index 5a70547d..3cde6ed6 100644
--- a/client/src/translations/en.js
+++ b/client/src/translations/en.js
@@ -195,7 +195,8 @@ export const translations = {
   "Enter the disco": "Enter the disco",
   "Exchange pieces' positions": "Exchange pieces' positions",
   "Exotic captures": "Exotic captures",
-  "Explosive captures": "Explosive captures",
+  "Explosive captures (v1)": "Explosive captures (v1)",
+  "Explosive captures (v2)": "Explosive captures (v2)",
   "Extra bishops and knights": "Extra bishops and knights",
   "Faster development": "Faster development",
   "Four new pieces": "Four new pieces",
@@ -213,6 +214,7 @@ export const translations = {
   "Kings cross the 11x11 board": "Kings cross the 11x11 board",
   "Knight in pocket": "Knight in pocket",
   "Knight versus pawns": "Knight versus pawns",
+  "Lancers everywhere": "Lancers everywhere",
   "Landing on the board": "Landing on the board",
   "Laws of attraction": "Laws of attraction",
   "Long jumps over pieces": "Long jumps over pieces",
diff --git a/client/src/translations/es.js b/client/src/translations/es.js
index ea64d3fc..612b0e35 100644
--- a/client/src/translations/es.js
+++ b/client/src/translations/es.js
@@ -195,7 +195,8 @@ export const translations = {
   "Enter the disco": "Entrar en la discoteca",
   "Exchange pieces' positions": "Intercambiar posiciones de piezas",
   "Exotic captures": "Capturas exóticas",
-  "Explosive captures": "Capturas explosivas",
+  "Explosive captures (v1)": "Capturas explosivas (v1)",
+  "Explosive captures (v2)": "Capturas explosivas (v2)",
   "Extra bishops and knights": "Alfiles y caballos adicionales",
   "Faster development": "Desarrollo acelerado",
   "Four new pieces": "Quatro nuevas piezas",
@@ -213,6 +214,7 @@ export const translations = {
   "Kings cross the 11x11 board": "Los reyes cruzan el 11x11 tablero",
   "Knight in pocket": "Caballo en bolsillo",
   "Knight versus pawns": "Caballo contra peones",
+  "Lancers everywhere": "Lanceros por todas partes",
   "Landing on the board": "Aterrizando en el tablero",
   "Laws of attraction": "Las leyes de las atracciones",
   "Long jumps over pieces": "Saltos largos sobre las piezas",
diff --git a/client/src/translations/fr.js b/client/src/translations/fr.js
index ccd82be3..6163dc45 100644
--- a/client/src/translations/fr.js
+++ b/client/src/translations/fr.js
@@ -195,7 +195,8 @@ export const translations = {
   "Enter the disco": "Entrez dans la boîte",
   "Exchange pieces' positions": "Échangez les positions des pièces",
   "Exotic captures": "Captures exotiques",
-  "Explosive captures": "Captures explosives",
+  "Explosive captures (v1)": "Captures explosives (v1)",
+  "Explosive captures (v2)": "Captures explosives (v2)",
   "Extra bishops and knights": "Fous et cavaliers supplémentaires",
   "Faster development": "Développement accéléré",
   "Four new pieces": "Quatre nouvelles pièces",
@@ -213,6 +214,7 @@ export const translations = {
   "Kings cross the 11x11 board": "Les rois traversent l'échiquier 11x11",
   "Knight in pocket": "Cavalier en poche",
   "Knight versus pawns": "Cavalier contre pions",
+  "Lancers everywhere": "Lanciers à tous les coins",
   "Landing on the board": "Débarquement sur l'échiquier",
   "Laws of attraction": "Les lois de l'attraction",
   "Long jumps over pieces": "Sauts longs par dessus les pièces",
diff --git a/client/src/translations/rules/Atomic/en.pug b/client/src/translations/rules/Atomic1/en.pug
similarity index 100%
rename from client/src/translations/rules/Atomic/en.pug
rename to client/src/translations/rules/Atomic1/en.pug
diff --git a/client/src/translations/rules/Atomic/es.pug b/client/src/translations/rules/Atomic1/es.pug
similarity index 100%
rename from client/src/translations/rules/Atomic/es.pug
rename to client/src/translations/rules/Atomic1/es.pug
diff --git a/client/src/translations/rules/Atomic/fr.pug b/client/src/translations/rules/Atomic1/fr.pug
similarity index 100%
rename from client/src/translations/rules/Atomic/fr.pug
rename to client/src/translations/rules/Atomic1/fr.pug
diff --git a/client/src/translations/rules/Atomic2/en.pug b/client/src/translations/rules/Atomic2/en.pug
new file mode 100644
index 00000000..dc0e87a0
--- /dev/null
+++ b/client/src/translations/rules/Atomic2/en.pug
@@ -0,0 +1,23 @@
+p.boxed.
+  Atomic1, but white's first move is a pawn removal.
+
+p.
+  At the very first move of the game, white must remove a pawn,
+  from either side.
+  Black then replies, and the game continues normally.
+
+figure.diagram-container
+  .diagram
+    | fen:rnbqkbnr/pppppppp/8/8/8/8/PPPP1PPP/RNBQKBNR:
+  figcaption.
+    After 1.e2X, pawn removal at e2.
+
+h3 More information
+
+p
+  | This variant aims at balancing the big white's advantage in Atomic1.
+  | It was suggested (relayed?) and analyzed recently (2020) by a strong
+  | Atomic player (Gannet on Discord). See
+  a(href="https://discord.com/channels/686736099959504907/687076744095858762/762398439043498046")
+    | the messages
+  | &nbsp;on Discord vchess server.
diff --git a/client/src/translations/rules/Atomic2/es.pug b/client/src/translations/rules/Atomic2/es.pug
new file mode 100644
index 00000000..21203baa
--- /dev/null
+++ b/client/src/translations/rules/Atomic2/es.pug
@@ -0,0 +1 @@
+p.boxed TODO
diff --git a/client/src/translations/rules/Atomic2/fr.pug b/client/src/translations/rules/Atomic2/fr.pug
new file mode 100644
index 00000000..21203baa
--- /dev/null
+++ b/client/src/translations/rules/Atomic2/fr.pug
@@ -0,0 +1 @@
+p.boxed TODO
diff --git a/client/src/translations/rules/Fullcavalry/en.pug b/client/src/translations/rules/Fullcavalry/en.pug
new file mode 100644
index 00000000..6bb88da3
--- /dev/null
+++ b/client/src/translations/rules/Fullcavalry/en.pug
@@ -0,0 +1,23 @@
+p.boxed
+  | Rooks are replaced by lancers from Eightpieces variant.
+
+p
+  | Everything is the same as in orthodox rules, except that rooks are
+  | replaced by lancers, as defined in the 
+  a(href="/variants/Eightpieces") Eightpieces variant
+  | .
+
+p.
+  White lancers are facing diagonally upward, while black lancers point
+  diagonally down in the deterministic initial setup.
+  In the randomized version, to avoid complex setup rules,
+  all lancers are facing up.
+
+figure.diagram-container
+  .diagram
+    | fen:efbqkbnm/pppppppp/8/8/8/8/PPPPPPPP/EDBQKBNM:
+  figcaption Initial deterministic position.
+
+h3 More information
+
+p TODO
diff --git a/client/src/translations/rules/Fullcavalry/es.pug b/client/src/translations/rules/Fullcavalry/es.pug
new file mode 100644
index 00000000..21203baa
--- /dev/null
+++ b/client/src/translations/rules/Fullcavalry/es.pug
@@ -0,0 +1 @@
+p.boxed TODO
diff --git a/client/src/translations/rules/Fullcavalry/fr.pug b/client/src/translations/rules/Fullcavalry/fr.pug
new file mode 100644
index 00000000..2605db40
--- /dev/null
+++ b/client/src/translations/rules/Fullcavalry/fr.pug
@@ -0,0 +1,24 @@
+p.boxed
+  | Les tours sont remplacées par des lanciers de la variante Eightpieces.
+
+p
+  | Tout se déroule comme aux échecs orthodoxes, sauf en ce qui concerne
+  | les tours qui sont remplacées par des lanciers comme défini dans la 
+  a(href="variants/Eightpieces") variante Eightpieces
+  | .
+
+p.
+  Les lanciers blancs regarde vers l'avant en diagonale, tandis que les
+  lanciers noirs pointent vers le sud (toujours en diagonale) dans
+  l'arrangement initial déterministe.
+  Dans la version aléatoire, tous les lanciers regardent droit devant afin
+  d'éviter des règles d'initialisation complexes.
+
+figure.diagram-container
+  .diagram
+    | fen:efbqkbnm/pppppppp/8/8/8/8/PPPPPPPP/EDBQKBNM:
+  figcaption Position initiale déterministe.
+
+h3 Plus d'information
+
+p TODO
diff --git a/client/src/translations/rules/Grand/en.pug b/client/src/translations/rules/Grand/en.pug
index 5154cdfa..c97096b5 100644
--- a/client/src/translations/rules/Grand/en.pug
+++ b/client/src/translations/rules/Grand/en.pug
@@ -15,10 +15,7 @@ figure.diagram-container
 
 h3 Special moves
 
-p.
-  Castling is possible as in orthodox 8x8 game. The white king move to c1 or
-  i1 (one square to the left of bottom-right corner) for large (resp. small)
-  castle. Same for black on the other side.
+p Castling is not permitted.
 
 p.
   Promotion is mandatory for a pawn reaching the last rank. However, they can
@@ -30,12 +27,6 @@ p.
   Pawn promotion is possible (but not forced) on the two ranks before last,
   only in an already captured (friendly) piece.
 
-p.
-  Note: I changed the author's starting position, to increase randomness
-  (and uniformize with other variants).
-  Thus the castling rule was introduced compared to the rules described
-  on chessvariants.com.
-
 h3 Source
 
 p
diff --git a/client/src/translations/rules/Grand/es.pug b/client/src/translations/rules/Grand/es.pug
index 38970302..363857cd 100644
--- a/client/src/translations/rules/Grand/es.pug
+++ b/client/src/translations/rules/Grand/es.pug
@@ -16,11 +16,7 @@ figure.diagram-container
 
 h3 Movimientos especiales
 
-p.
-  El enroque es posible como en un juego con un tablero 8x8.
-  El rey blanco va a c1 o i1 (un cuadro a la izquierda de la esquina
-  inferior derecha) para un enroque grande (resp. pequeño).
-  Lo mismo para las negras del otro lado.
+p No se permite el enroque.
 
 p.
   La promoción es obligatoria para los peones que llegan a la última fila,
@@ -32,12 +28,6 @@ p.
   La promoción es posible (pero no obligatoria) en las octava y novena
   filas, siempre en una pieza amiga capturada.
 
-p.
-  Nota: cambié la posición inicial planificada por el autor, a
-  aumentar el alea de la situación inicial (y estandarizar con los demás
-  variantes). De repente, la regla de enroque se agregó en comparación con las
-  reglas inicialmente descrito.
-
 h3 Fuente
 
 p
diff --git a/client/src/translations/rules/Grand/fr.pug b/client/src/translations/rules/Grand/fr.pug
index b058b77c..c84d1ae9 100644
--- a/client/src/translations/rules/Grand/fr.pug
+++ b/client/src/translations/rules/Grand/fr.pug
@@ -16,10 +16,7 @@ figure.diagram-container
 
 h3 Coups spéciaux
 
-p.
-  Le roque est possible comme dans une partie sur un échiquier 8x8.
-  Le roi blanc va en c1 ou i1 (une case à gauche du coin inférieur droit)
-  pour un grand (resp. petit) roque. Pareil pour les noirs de l'autre côté.
+p Le roque n'est pas autorisé.
 
 p.
   La promotion est obligatoire pour les pions arrivant sur la dernière rangée,
@@ -31,12 +28,6 @@ p.
   La promotion est possible (mais non obligatoire) sur les huitième et neuvième
   rangées, toujours en une pièce amie déjà capturée.
 
-p.
-  Note : j'ai changé la position de départ prévue par l'auteur, pour
-  augmenter l'alea de la situation initiale (et uniformiser avec les autres
-  variantes). Du coup la règle du roque a été ajoutée comparée aux règles
-  décrites initialement.
-
 h3 Source
 
 p
diff --git a/client/src/translations/variants/en.pug b/client/src/translations/variants/en.pug
index 2607bcda..e99f97a4 100644
--- a/client/src/translations/variants/en.pug
+++ b/client/src/translations/variants/en.pug
@@ -113,6 +113,7 @@ p.
 -
   var varlist = [
     "Eightpieces",
+    "Fullcavalry",
     "Grand",
     "Grasshopper",
     "Omega",
@@ -264,7 +265,8 @@ p ...Or leading to a very different strategy:
 -
   var varlist = [
     "Antimatter",
-    "Atomic",
+    "Atomic1",
+    "Atomic2",
     "Checkless"
   ]
 ul
diff --git a/client/src/translations/variants/es.pug b/client/src/translations/variants/es.pug
index 094a85ef..ed3bd7cf 100644
--- a/client/src/translations/variants/es.pug
+++ b/client/src/translations/variants/es.pug
@@ -120,6 +120,7 @@ p.
 -
   var varlist = [
     "Eightpieces",
+    "Fullcavalry",
     "Grand",
     "Grasshopper",
     "Omega",
@@ -273,7 +274,8 @@ p ...O conduce a estrategias muy diferentes:
 -
   var varlist = [
     "Antimatter",
-    "Atomic",
+    "Atomic1",
+    "Atomic2",
     "Checkless"
   ]
 ul
diff --git a/client/src/translations/variants/fr.pug b/client/src/translations/variants/fr.pug
index 591b725c..b3e3f775 100644
--- a/client/src/translations/variants/fr.pug
+++ b/client/src/translations/variants/fr.pug
@@ -119,6 +119,7 @@ p.
 -
   var varlist = [
     "Eightpieces",
+    "Fullcavalry",
     "Grand",
     "Grasshopper",
     "Omega",
@@ -272,7 +273,8 @@ p ...Ou mène à des stratégies très différentes :
 -
   var varlist = [
     "Antimatter",
-    "Atomic",
+    "Atomic1",
+    "Atomic2",
     "Checkless"
   ]
 ul
diff --git a/client/src/variants/Atomic.js b/client/src/variants/Atomic1.js
similarity index 92%
rename from client/src/variants/Atomic.js
rename to client/src/variants/Atomic1.js
index e2f4bdf5..27769a7e 100644
--- a/client/src/variants/Atomic.js
+++ b/client/src/variants/Atomic1.js
@@ -1,6 +1,6 @@
 import { ChessRules, PiPo } from "@/base_rules";
 
-export class AtomicRules extends ChessRules {
+export class Atomic1Rules extends ChessRules {
 
   getPotentialMovesFrom([x, y]) {
     let moves = super.getPotentialMovesFrom([x, y]);
@@ -79,7 +79,8 @@ export class AtomicRules extends ChessRules {
 
   postPlay(move) {
     super.postPlay(move);
-    if (move.appear.length == 0) {
+    // NOTE: (harmless) condition on movesCount for Atomic2
+    if (move.appear.length == 0 && this.movesCount >= 2) {
       // Capture
       const firstRank = { w: 7, b: 0 };
       for (let c of ["w", "b"]) {
@@ -107,7 +108,11 @@ export class AtomicRules extends ChessRules {
     super.postUndo(move);
     const c = this.turn;
     const oppCol = V.GetOppCol(c);
-    if ([this.kingPos[c][0], this.kingPos[oppCol][0]].some(e => e < 0)) {
+    // NOTE: condition on movesCount for Atomic2
+    if (
+      this.movesCount >= 1 &&
+      [this.kingPos[c][0], this.kingPos[oppCol][0]].some(e => e < 0)
+    ) {
       // There is a chance that last move blowed some king away..
       for (let psq of move.vanish) {
         if (psq.p == "k")
diff --git a/client/src/variants/Atomic2.js b/client/src/variants/Atomic2.js
new file mode 100644
index 00000000..9ea22961
--- /dev/null
+++ b/client/src/variants/Atomic2.js
@@ -0,0 +1,56 @@
+import { ChessRules, Move, PiPo } from "@/base_rules";
+import { Atomic1Rules } from "@/variants/Atomic1";
+
+export class Atomic2Rules extends Atomic1Rules {
+
+  getPotentialMovesFrom([x, y]) {
+    if (this.movesCount == 0) {
+      if ([1, 6].includes(x)) {
+        const c = this.getColor(x, y);
+        return [
+          new Move({
+            appear: [],
+            vanish: [
+              new PiPo({ x: x, y: y, p: V.PAWN, c: c })
+            ],
+            start: { x: x, y: y },
+            end: { x: x, y: y }
+          })
+        ];
+      }
+      return [];
+    }
+    return super.getPotentialMovesFrom([x, y]);
+  }
+
+  hoverHighlight(x, y) {
+    return this.movesCount == 0 && [1, 6].includes(x);
+  }
+
+  doClick(square) {
+    if (this.movesCount >= 1) return null;
+    const [x, y] = [square[0], square[1]];
+    if (![1, 6].includes(x)) return null;
+    return new Move({
+      appear: [],
+      vanish: [
+        new PiPo({
+          x: x,
+          y: y,
+          c: this.getColor(x, y),
+          p: V.PAWN
+        })
+      ],
+      start: { x: x, y: y },
+      end: { x: x, y: y }
+    });
+  }
+
+  getNotation(move) {
+    if (move.appear.length == 0 && move.vanish.length == 1)
+      // First move in game
+      return V.CoordsToSquare(move.start) + "X";
+    return super.getNotation(move);
+  }
+
+};
diff --git a/client/src/variants/Eightpieces.js b/client/src/variants/Eightpieces.js
index 3e155009..1fbc5d0b 100644
--- a/client/src/variants/Eightpieces.js
+++ b/client/src/variants/Eightpieces.js
@@ -1,4 +1,3 @@
-import { ArrayFun } from "@/utils/array";
 import { randInt } from "@/utils/alea";
 import { ChessRules, PiPo, Move } from "@/base_rules";
 
@@ -170,79 +169,56 @@ export class EightpiecesRules extends ChessRules {
 
   static GenRandInitFen(randomness) {
     if (randomness == 0)
-      // Deterministic:
       return "jfsqkbnr/pppppppp/8/8/8/8/PPPPPPPP/JDSQKBNR w 0 ahah - -";
 
-    let pieces = { w: new Array(8), b: new Array(8) };
-    let flags = "";
-    // Shuffle pieces on first (and last rank if randomness == 2)
-    for (let c of ["w", "b"]) {
-      if (c == 'b' && randomness == 1) {
-        const lancerIdx = pieces['w'].findIndex(p => {
-          return Object.keys(V.LANCER_DIRS).includes(p);
-        });
-        pieces['b'] =
-          pieces['w'].slice(0, lancerIdx)
-          .concat(['g'])
-          .concat(pieces['w'].slice(lancerIdx + 1));
-        flags += flags;
-        break;
-      }
-
-      let positions = ArrayFun.range(8);
-
-      // Get random squares for bishop and sentry
-      let randIndex = 2 * randInt(4);
-      let bishopPos = positions[randIndex];
-      // The sentry must be on a square of different color
-      let randIndex_tmp = 2 * randInt(4) + 1;
-      let sentryPos = positions[randIndex_tmp];
-      if (c == 'b') {
-        // Check if white sentry is on the same color as ours.
-        // If yes: swap bishop and sentry positions.
-        // NOTE: test % 2 == 1 because there are 7 slashes.
-        if ((pieces['w'].indexOf('s') - sentryPos) % 2 == 1)
-          [bishopPos, sentryPos] = [sentryPos, bishopPos];
+    const baseFen = ChessRules.GenRandInitFen(randomness);
+    const fenParts = baseFen.split(' ');
+    const posParts = fenParts[0].split('/');
+
+    // Replace one bishop by sentry, so that sentries on different colors
+    // Also replace one random rook by jailer,
+    // and one random knight by lancer (facing north/south)
+
+    // "replaced" array contains -2 initially, then either -1 if skipped,
+    // or (eventually) the index of replacement:
+    let newPos = { 0: "", 7: "" };
+    let sentryOddity = -1;
+    for (let rank of [0, 7]) {
+      let replaced = { 'b': -2, 'n': -2, 'r': -2 };
+      for (let i = 0; i < 8; i++) {
+        const curChar = posParts[rank].charAt(i).toLowerCase();
+        if (['b', 'n', 'r'].includes(curChar)) {
+          if (
+            replaced[curChar] == -1 ||
+            (curChar == 'b' && rank == 7 && i % 2 == sentryOddity) ||
+            (
+              (curChar != 'b' || rank == 0) &&
+              replaced[curChar] == -2 &&
+              randInt(2) == 0
+            )
+          ) {
+            replaced[curChar] = i;
+            if (curChar == 'b') {
+              if (sentryOddity < 0) sentryOddity = i % 2;
+              newPos[rank] += 's';
+            }
+            else if (curChar == 'r') newPos[rank] += 'j';
+            else
+              // Lancer: orientation depends on side
+              newPos[rank] += (rank == 0 ? 'g' : 'c');
+          }
+          else {
+            if (replaced[curChar] == -2) replaced[curChar]++;
+            newPos[rank] += curChar;
+          }
+        }
+        else newPos[rank] += curChar;
       }
-      positions.splice(Math.max(randIndex, randIndex_tmp), 1);
-      positions.splice(Math.min(randIndex, randIndex_tmp), 1);
-
-      // Get random squares for knight and lancer
-      randIndex = randInt(6);
-      const knightPos = positions[randIndex];
-      positions.splice(randIndex, 1);
-      randIndex = randInt(5);
-      const lancerPos = positions[randIndex];
-      positions.splice(randIndex, 1);
-
-      // Get random square for queen
-      randIndex = randInt(4);
-      const queenPos = positions[randIndex];
-      positions.splice(randIndex, 1);
-
-      // Rook, jailer and king positions are now almost fixed,
-      // only the ordering rook->jailer or jailer->rook must be decided.
-      let rookPos = positions[0];
-      let jailerPos = positions[2];
-      const kingPos = positions[1];
-      flags += V.CoordToColumn(rookPos) + V.CoordToColumn(jailerPos);
-      if (Math.random() < 0.5) [rookPos, jailerPos] = [jailerPos, rookPos];
-
-      pieces[c][rookPos] = "r";
-      pieces[c][knightPos] = "n";
-      pieces[c][bishopPos] = "b";
-      pieces[c][queenPos] = "q";
-      pieces[c][kingPos] = "k";
-      pieces[c][sentryPos] = "s";
-      // Lancer faces north for white, and south for black:
-      pieces[c][lancerPos] = c == 'w' ? 'c' : 'g';
-      pieces[c][jailerPos] = "j";
     }
+
     return (
-      pieces["b"].join("") +
-      "/pppppppp/8/8/8/8/PPPPPPPP/" +
-      pieces["w"].join("").toUpperCase() +
-      " w 0 " + flags + " - -"
+      newPos[0] + "/" + posParts.slice(1, 7).join('/') + "/" +
+      newPos[7].toUpperCase() + " " + fenParts.slice(1, 5).join(' ') + " -"
     );
   }
 
@@ -384,7 +360,8 @@ export class EightpiecesRules extends ChessRules {
         }
         return true;
       });
-    } else if (this.subTurn == 2) {
+    }
+    else if (this.subTurn == 2) {
       // Put back the sentinel on board:
       const color = this.turn;
       moves.forEach(m => {
diff --git a/client/src/variants/Fullcavalry.js b/client/src/variants/Fullcavalry.js
new file mode 100644
index 00000000..c25f3400
--- /dev/null
+++ b/client/src/variants/Fullcavalry.js
@@ -0,0 +1,268 @@
+import { ArrayFun } from "@/utils/array";
+import { randInt } from "@/utils/alea";
+import { ChessRules, PiPo, Move } from "@/base_rules";
+
+export class FullcavalryRules extends ChessRules {
+
+  static get LANCER() {
+    return "l";
+  }
+
+  static get IMAGE_EXTENSION() {
+    // Temporarily, for the time SVG pieces are being designed:
+    return ".png";
+  }
+
+  // Lancer directions *from white perspective*
+  static get LANCER_DIRS() {
+    return {
+      'c': [-1, 0], //north
+      'd': [-1, 1], //N-E
+      'e': [0, 1], //east
+      'f': [1, 1], //S-E
+      'g': [1, 0], //south
+      'h': [1, -1], //S-W
+      'm': [0, -1], //west
+      'o': [-1, -1] //N-W
+    };
+  }
+
+  static get PIECES() {
+    return ChessRules.PIECES.concat(Object.keys(V.LANCER_DIRS));
+  }
+
+  getPiece(i, j) {
+    const piece = this.board[i][j].charAt(1);
+    // Special lancer case: 8 possible orientations
+    if (Object.keys(V.LANCER_DIRS).includes(piece)) return V.LANCER;
+    return piece;
+  }
+
+  getPpath(b, color, score, orientation) {
+    if (Object.keys(V.LANCER_DIRS).includes(b[1])) {
+      if (orientation == 'w') return "Eightpieces/tmp_png/" + b;
+      // Find opposite direction for adequate display:
+      let oppDir = '';
+      switch (b[1]) {
+        case 'c':
+          oppDir = 'g';
+          break;
+        case 'g':
+          oppDir = 'c';
+          break;
+        case 'd':
+          oppDir = 'h';
+          break;
+        case 'h':
+          oppDir = 'd';
+          break;
+        case 'e':
+          oppDir = 'm';
+          break;
+        case 'm':
+          oppDir = 'e';
+          break;
+        case 'f':
+          oppDir = 'o';
+          break;
+        case 'o':
+          oppDir = 'f';
+          break;
+      }
+      return "Eightpieces/tmp_png/" + b[0] + oppDir;
+    }
+    // TODO: after we have SVG pieces, remove the folder and next prefix:
+    return "Eightpieces/tmp_png/" + b;
+  }
+
+  getPPpath(m, orientation) {
+    return (
+      this.getPpath(
+        m.appear[0].c + m.appear[0].p,
+        null,
+        null,
+        orientation
+      )
+    );
+  }
+
+  static GenRandInitFen(randomness) {
+    if (randomness == 0)
+      // Deterministic:
+      return "efbqkbnm/pppppppp/8/8/8/8/PPPPPPPP/EDBQKBNM w 0 ahah -";
+
+    const baseFen = ChessRules.GenRandInitFen(randomness);
+    // Replace black rooks by lancers oriented south,
+    // and white rooks by lancers oriented north:
+    return baseFen.replace(/r/g, 'g').replace(/R/g, 'C');
+  }
+
+  // Because of the lancers, getPiece() could be wrong:
+  // use board[x][y][1] instead (always valid).
+  // TODO: base implementation now uses this too (no?)
+  getBasicMove([sx, sy], [ex, ey], tr) {
+    const initColor = this.getColor(sx, sy);
+    const initPiece = this.board[sx][sy].charAt(1);
+    let mv = new Move({
+      appear: [
+        new PiPo({
+          x: ex,
+          y: ey,
+          c: tr ? tr.c : initColor,
+          p: tr ? tr.p : initPiece
+        })
+      ],
+      vanish: [
+        new PiPo({
+          x: sx,
+          y: sy,
+          c: initColor,
+          p: initPiece
+        })
+      ]
+    });
+
+    // The opponent piece disappears if we take it
+    if (this.board[ex][ey] != V.EMPTY) {
+      mv.vanish.push(
+        new PiPo({
+          x: ex,
+          y: ey,
+          c: this.getColor(ex, ey),
+          p: this.board[ex][ey].charAt(1)
+        })
+      );
+    }
+
+    return mv;
+  }
+
+  getPotentialMovesFrom([x, y]) {
+    if (this.getPiece(x, y) == V.LANCER)
+      return this.getPotentialLancerMoves([x, y]);
+    return super.getPotentialMovesFrom([x, y]);
+  }
+
+  // Obtain all lancer moves in "step" direction
+  getPotentialLancerMoves_aux([x, y], step, tr) {
+    let moves = [];
+    // Add all moves to vacant squares until opponent is met:
+    const color = this.getColor(x, y);
+    const oppCol = V.GetOppCol(color)
+    let sq = [x + step[0], y + step[1]];
+    while (V.OnBoard(sq[0], sq[1]) && this.getColor(sq[0], sq[1]) != oppCol) {
+      if (this.board[sq[0]][sq[1]] == V.EMPTY)
+        moves.push(this.getBasicMove([x, y], sq, tr));
+      sq[0] += step[0];
+      sq[1] += step[1];
+    }
+    if (V.OnBoard(sq[0], sq[1]))
+      // Add capturing move
+      moves.push(this.getBasicMove([x, y], sq, tr));
+    return moves;
+  }
+
+  getPotentialLancerMoves([x, y]) {
+    let moves = [];
+    // Add all lancer possible orientations, similar to pawn promotions.
+    const color = this.getColor(x, y);
+    const dirCode = this.board[x][y][1];
+    const curDir = V.LANCER_DIRS[dirCode];
+    const monodirMoves =
+      this.getPotentialLancerMoves_aux([x, y], V.LANCER_DIRS[dirCode]);
+    monodirMoves.forEach(m => {
+      Object.keys(V.LANCER_DIRS).forEach(k => {
+        const newDir = V.LANCER_DIRS[k];
+        // Prevent orientations toward outer board:
+        if (V.OnBoard(m.end.x + newDir[0], m.end.y + newDir[1])) {
+          let mk = JSON.parse(JSON.stringify(m));
+          mk.appear[0].p = k;
+          moves.push(mk);
+        }
+      });
+    });
+    return moves;
+  }
+
+  isAttacked(sq, color) {
+    return (
+      super.isAttacked(sq, color) ||
+      this.isAttackedByLancer(sq, color)
+    );
+  }
+
+  isAttackedByLancer([x, y], color) {
+    for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
+      // If in this direction there are only enemy pieces and empty squares,
+      // and we meet a lancer: can he reach us?
+      // NOTE: do not stop at first lancer, there might be several!
+      let coord = { x: x + step[0], y: y + step[1] };
+      let lancerPos = [];
+      while (
+        V.OnBoard(coord.x, coord.y) &&
+        (
+          this.board[coord.x][coord.y] == V.EMPTY ||
+          this.getColor(coord.x, coord.y) == color
+        )
+      ) {
+        if (
+          this.getPiece(coord.x, coord.y) == V.LANCER &&
+          !this.isImmobilized([coord.x, coord.y])
+        ) {
+          lancerPos.push({x: coord.x, y: coord.y});
+        }
+        coord.x += step[0];
+        coord.y += step[1];
+      }
+      for (let xy of lancerPos) {
+        const dir = V.LANCER_DIRS[this.board[xy.x][xy.y].charAt(1)];
+        if (dir[0] == -step[0] && dir[1] == -step[1]) return true;
+      }
+    }
+    return false;
+  }
+
+  static get VALUES() {
+    return Object.assign(
+      { l: 4.8 }, //Jeff K. estimation (for Eightpieces)
+      ChessRules.VALUES
+    );
+  }
+
+  // For moves notation:
+  static get LANCER_DIRNAMES() {
+    return {
+      'c': "N",
+      'd': "NE",
+      'e': "E",
+      'f': "SE",
+      'g': "S",
+      'h': "SW",
+      'm': "W",
+      'o': "NW"
+    };
+  }
+
+  filterValid(moves) {
+    // At move 1, forbid captures (in case of...):
+    if (this.movesCount >= 2) return moves;
+    return moves.filter(m => m.vanish.length == 1);
+  }
+
+  getNotation(move) {
+    let notation = super.getNotation(move);
+    if (Object.keys(V.LANCER_DIRNAMES).includes(move.vanish[0].p))
+      // Lancer: add direction info
+      notation += "=" + V.LANCER_DIRNAMES[move.appear[0].p];
+    else if (
+      move.vanish[0].p == V.PAWN &&
+      Object.keys(V.LANCER_DIRNAMES).includes(move.appear[0].p)
+    ) {
+      // Fix promotions in lancer:
+      notation = notation.slice(0, -1) +
+        "L:" + V.LANCER_DIRNAMES[move.appear[0].p];
+    }
+    return notation;
+  }
+
+};
diff --git a/client/src/variants/Grand.js b/client/src/variants/Grand.js
index 398a96cc..5dc355f4 100644
--- a/client/src/variants/Grand.js
+++ b/client/src/variants/Grand.js
@@ -2,10 +2,12 @@ import { ChessRules } from "@/base_rules";
 import { ArrayFun } from "@/utils/array";
 import { randInt } from "@/utils/alea";
 
-// NOTE: initial setup differs from the original; see
-// https://www.chessvariants.com/large.dir/freeling.html
 export class GrandRules extends ChessRules {
 
+  static get HasCastle() {
+    return false;
+  }
+
   static IsGoodFen(fen) {
     if (!ChessRules.IsGoodFen(fen)) return false;
     const fenParsed = V.ParseFen(fen);
@@ -24,7 +26,7 @@ export class GrandRules extends ChessRules {
     const fenParts = fen.split(" ");
     return Object.assign(
       ChessRules.ParseFen(fen),
-      { captured: fenParts[5] }
+      { captured: fenParts[4] }
     );
   }
 
@@ -97,52 +99,6 @@ export class GrandRules extends ChessRules {
     return ChessRules.PIECES.concat([V.MARSHALL, V.CARDINAL]);
   }
 
-  // There may be 2 enPassant squares (if pawn jump 3 squares)
-  getEnpassantFen() {
-    const L = this.epSquares.length;
-    if (!this.epSquares[L - 1]) return "-"; //no en-passant
-    let res = "";
-    this.epSquares[L - 1].forEach(sq => {
-      res += V.CoordsToSquare(sq) + ",";
-    });
-    return res.slice(0, -1); //remove last comma
-  }
-
-  // En-passant after 2-sq or 3-sq jumps
-  getEpSquare(moveOrSquare) {
-    if (!moveOrSquare) return undefined;
-    if (typeof moveOrSquare === "string") {
-      const square = moveOrSquare;
-      if (square == "-") return undefined;
-      let res = [];
-      square.split(",").forEach(sq => {
-        res.push(V.SquareToCoords(sq));
-      });
-      return res;
-    }
-    // Argument is a move:
-    const move = moveOrSquare;
-    const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x];
-    if (this.getPiece(sx, sy) == V.PAWN && Math.abs(sx - ex) >= 2) {
-      const step = (ex - sx) / Math.abs(ex - sx);
-      let res = [
-        {
-          x: sx + step,
-          y: sy
-        }
-      ];
-      if (sx + 2 * step != ex) {
-        // 3-squares jump
-        res.push({
-          x: sx + 2 * step,
-          y: sy
-        });
-      }
-      return res;
-    }
-    return undefined; //default
-  }
-
   getPotentialMovesFrom([x, y]) {
     switch (this.getPiece(x, y)) {
       case V.MARSHALL:
@@ -161,7 +117,7 @@ export class GrandRules extends ChessRules {
     let moves = [];
     const [sizeX, sizeY] = [V.size.x, V.size.y];
     const shiftX = color == "w" ? -1 : 1;
-    const startRanks = color == "w" ? [sizeX - 2, sizeX - 3] : [1, 2];
+    const startRank = (color == "w" ? sizeX - 3 : 2);
     const lastRanks =
       color == "w" ? [0, 1, 2] : [sizeX - 1, sizeX - 2, sizeX - 3];
     const promotionPieces = [
@@ -178,23 +134,17 @@ export class GrandRules extends ChessRules {
     if (lastRanks.includes(x + shiftX)) {
       finalPieces = promotionPieces.filter(p => this.captured[color][p] > 0);
       if (x + shiftX != lastRanks[0]) finalPieces.push(V.PAWN);
-    } else finalPieces = [V.PAWN];
+    }
+    else finalPieces = [V.PAWN];
     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], { c: color, p: piece })
         );
-      if (startRanks.includes(x)) {
-        if (this.board[x + 2 * shiftX][y] == V.EMPTY) {
-          // Two squares jump
-          moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
-          if (x == startRanks[0] && this.board[x + 3 * shiftX][y] == V.EMPTY) {
-            // Three squares jump
-            moves.push(this.getBasicMove([x, y], [x + 3 * shiftX, y]));
-          }
-        }
-      }
+      if (x == startRank && this.board[x + 2 * shiftX][y] == V.EMPTY)
+        // Two squares jump
+        moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
     }
     // Captures
     for (let shiftY of [-1, 1]) {
@@ -216,32 +166,14 @@ export class GrandRules extends ChessRules {
     }
 
     // En passant
-    const Lep = this.epSquares.length;
-    const epSquare = this.epSquares[Lep - 1];
-    if (!!epSquare) {
-      for (let epsq of epSquare) {
-        // TODO: some redundant checks
-        if (epsq.x == x + shiftX && Math.abs(epsq.y - y) == 1) {
-          let enpassantMove = this.getBasicMove([x, y], [epsq.x, epsq.y]);
-          // WARNING: the captured pawn may be diagonally behind us,
-          // if it's a 3-squares jump and we take on 1st passing square
-          const px = this.board[x][epsq.y] != V.EMPTY ? x : x - shiftX;
-          enpassantMove.vanish.push({
-            x: px,
-            y: epsq.y,
-            p: "p",
-            c: this.getColor(px, epsq.y)
-          });
-          moves.push(enpassantMove);
-        }
-      }
-    }
+    Array.prototype.push.apply(
+      moves,
+      this.getEnpassantCaptures([x, y], shiftX)
+    );
 
     return moves;
   }
 
-  // TODO: different castle?
-
   getPotentialMarshallMoves(sq) {
     return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
       this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
@@ -316,64 +248,57 @@ export class GrandRules extends ChessRules {
     if (randomness == 0) {
       return (
         "r8r/1nbqkmcbn1/pppppppppp/91/91/91/91/PPPPPPPPPP/1NBQKMCBN1/R8R " +
-        // No castling in the official initial setup
-        "w 0 zzzz - 00000000000000"
+        "w 0 - 00000000000000"
       );
     }
 
-    let pieces = { w: new Array(10), b: new Array(10) };
-    let flags = "";
-    // Shuffle pieces on first and last rank
+    let pieces = { w: new Array(8), b: new Array(8) };
+    // Shuffle pieces on second and before-last rank
     for (let c of ["w", "b"]) {
       if (c == 'b' && randomness == 1) {
         pieces['b'] = pieces['w'];
-        flags += flags;
         break;
       }
 
-      let positions = ArrayFun.range(10);
+      let positions = ArrayFun.range(8);
 
       // Get random squares for bishops
-      let randIndex = 2 * randInt(5);
+      let randIndex = 2 * randInt(4);
       let bishop1Pos = positions[randIndex];
       // The second bishop must be on a square of different color
-      let randIndex_tmp = 2 * randInt(5) + 1;
+      let randIndex_tmp = 2 * randInt(4) + 1;
       let bishop2Pos = positions[randIndex_tmp];
       // Remove chosen squares
       positions.splice(Math.max(randIndex, randIndex_tmp), 1);
       positions.splice(Math.min(randIndex, randIndex_tmp), 1);
 
       // Get random squares for knights
-      randIndex = randInt(8);
+      randIndex = randInt(6);
       let knight1Pos = positions[randIndex];
       positions.splice(randIndex, 1);
-      randIndex = randInt(7);
+      randIndex = randInt(5);
       let knight2Pos = positions[randIndex];
       positions.splice(randIndex, 1);
 
       // Get random square for queen
-      randIndex = randInt(6);
+      randIndex = randInt(4);
       let queenPos = positions[randIndex];
       positions.splice(randIndex, 1);
 
       // ...random square for marshall
-      randIndex = randInt(5);
+      randIndex = randInt(3);
       let marshallPos = positions[randIndex];
       positions.splice(randIndex, 1);
 
       // ...random square for cardinal
-      randIndex = randInt(4);
+      randIndex = randInt(2);
       let cardinalPos = positions[randIndex];
       positions.splice(randIndex, 1);
 
-      // Rooks and king positions are now fixed,
-      // because of the ordering rook-king-rook
-      let rook1Pos = positions[0];
-      let kingPos = positions[1];
-      let rook2Pos = positions[2];
+      // King position is now fixed,
+      let kingPos = positions[0];
 
       // Finally put the shuffled pieces in the board array
-      pieces[c][rook1Pos] = "r";
       pieces[c][knight1Pos] = "n";
       pieces[c][bishop1Pos] = "b";
       pieces[c][queenPos] = "q";
@@ -382,14 +307,12 @@ export class GrandRules extends ChessRules {
       pieces[c][kingPos] = "k";
       pieces[c][bishop2Pos] = "b";
       pieces[c][knight2Pos] = "n";
-      pieces[c][rook2Pos] = "r";
-      flags += V.CoordToColumn(rook1Pos) + V.CoordToColumn(rook2Pos);
     }
     return (
-      pieces["b"].join("") +
-      "/pppppppppp/91/91/91/91/91/91/PPPPPPPPPP/" +
-      pieces["w"].join("").toUpperCase() +
-      " w 0 " + flags + " - 00000000000000"
+      "r8r/1" + pieces["b"].join("") + "1/" +
+      "pppppppppp/91/91/91/91/PPPPPPPPPP/" +
+      "1" + pieces["w"].join("").toUpperCase() + "1/R8R" +
+      " w 0 " + " - 00000000000000"
     );
   }
 
diff --git a/client/src/variants/Losers.js b/client/src/variants/Losers.js
index 7bd5e541..ea283809 100644
--- a/client/src/variants/Losers.js
+++ b/client/src/variants/Losers.js
@@ -35,9 +35,6 @@ export class LosersRules extends ChessRules {
   getPossibleMovesFrom(sq) {
     let moves = this.filterValid(this.getPotentialMovesFrom(sq));
     const captureMoves = V.KeepCaptures(moves);
-
-console.log(this.atLeastOneCapture());
-
     if (captureMoves.length > 0) return captureMoves;
     if (this.atLeastOneCapture()) return [];
     return moves;
diff --git a/client/src/variants/Titan.js b/client/src/variants/Titan.js
index aadc3e70..e9b0594f 100644
--- a/client/src/variants/Titan.js
+++ b/client/src/variants/Titan.js
@@ -185,6 +185,14 @@ export class TitanRules extends ChessRules {
     return moves;
   }
 
+  hoverHighlight(x, y) {
+    const c = this.turn;
+    return (
+      this.movesCount <= 3 &&
+      ((c == 'w' && x == 7) || (c == 'b' && x == 0))
+    );
+  }
+
   // Special case of move 1 = choose squares, knight first, then bishop
   doClick(square) {
     if (this.movesCount >= 4) return null;
diff --git a/client/src/views/Analyse.vue b/client/src/views/Analyse.vue
index eb36422d..06ef7901 100644
--- a/client/src/views/Analyse.vue
+++ b/client/src/views/Analyse.vue
@@ -99,7 +99,7 @@ export default {
           this.alertAndQuit("Analysis disabled for this variant");
         else this.loadGame(orientation);
       })
-      .catch((err) => { this.alertAndQuit("Mispelled variant name", true); });
+      //.catch((err) => { this.alertAndQuit("Mispelled variant name", true); });
       this.rulesContent =
         afterRawLoad(
           require(
diff --git a/server/db/populate.sql b/server/db/populate.sql
index 47ed4a86..7def7a62 100644
--- a/server/db/populate.sql
+++ b/server/db/populate.sql
@@ -19,7 +19,8 @@ insert or ignore into Variants (name, description) values
   ('Antiking2', 'Keep antiking in check (v2)'),
   ('Antimatter', 'Dangerous collisions'),
   ('Arena', 'Middle battle'),
-  ('Atomic', 'Explosive captures'),
+  ('Atomic1', 'Explosive captures (v1)'),
+  ('Atomic2', 'Explosive captures (v2)'),
   ('Ball', 'Score a goal'),
   ('Balaklava', 'Meet the Mammoth'),
   ('Baroque', 'Exotic captures'),
@@ -54,6 +55,7 @@ insert or ignore into Variants (name, description) values
   ('Football', 'Score a goal'),
   ('Forward', 'Moving forward'),
   ('Freecapture', 'Capture both colors'),
+  ('Fullcavalry', 'Lancers everywhere'),
   ('Grand', 'Big board'),
   ('Grasshopper', 'Long jumps over pieces'),
   ('Gridolina', 'Jump the borders'),