From 723262f9b77ed0f916e5b9fcbfbae5ddfe94925c Mon Sep 17 00:00:00 2001
From: Benjamin Auder <benjamin.auder@somewhere>
Date: Tue, 16 Feb 2021 22:42:26 +0100
Subject: [PATCH] Add Pandemonium

---
 .../public/images/pieces/Pandemonium/ba.svg   |   1 +
 .../public/images/pieces/Pandemonium/bc.svg   |   1 +
 .../public/images/pieces/Pandemonium/bd.svg   |   1 +
 .../public/images/pieces/Pandemonium/bg.svg   |   1 +
 .../public/images/pieces/Pandemonium/bh.svg   |   1 +
 .../public/images/pieces/Pandemonium/bm.svg   |   1 +
 .../public/images/pieces/Pandemonium/bs.svg   |   1 +
 .../public/images/pieces/Pandemonium/bw.svg   |   1 +
 .../public/images/pieces/Pandemonium/wa.svg   |   1 +
 .../public/images/pieces/Pandemonium/wc.svg   |   1 +
 .../public/images/pieces/Pandemonium/wd.svg   |   1 +
 .../public/images/pieces/Pandemonium/wg.svg   |   1 +
 .../public/images/pieces/Pandemonium/wh.svg   |   1 +
 .../public/images/pieces/Pandemonium/wm.svg   |   1 +
 .../public/images/pieces/Pandemonium/ws.svg   |   1 +
 .../public/images/pieces/Pandemonium/ww.svg   |   1 +
 client/src/translations/en.js                 |   1 +
 client/src/translations/es.js                 |   1 +
 client/src/translations/fr.js                 |   1 +
 .../src/translations/rules/Pandemonium/en.pug |  63 ++
 .../src/translations/rules/Pandemonium/es.pug |  65 ++
 .../src/translations/rules/Pandemonium/fr.pug |  65 ++
 client/src/translations/variants/en.pug       |   1 +
 client/src/translations/variants/es.pug       |   1 +
 client/src/translations/variants/fr.pug       |   1 +
 client/src/variants/Omega.js                  |  12 +-
 client/src/variants/Pandemonium.js            | 785 ++++++++++++++++++
 client/src/variants/Shogi.js                  |  20 +-
 server/db/populate.sql                        |   1 +
 29 files changed, 1016 insertions(+), 17 deletions(-)
 create mode 120000 client/public/images/pieces/Pandemonium/ba.svg
 create mode 120000 client/public/images/pieces/Pandemonium/bc.svg
 create mode 120000 client/public/images/pieces/Pandemonium/bd.svg
 create mode 120000 client/public/images/pieces/Pandemonium/bg.svg
 create mode 120000 client/public/images/pieces/Pandemonium/bh.svg
 create mode 120000 client/public/images/pieces/Pandemonium/bm.svg
 create mode 120000 client/public/images/pieces/Pandemonium/bs.svg
 create mode 120000 client/public/images/pieces/Pandemonium/bw.svg
 create mode 120000 client/public/images/pieces/Pandemonium/wa.svg
 create mode 120000 client/public/images/pieces/Pandemonium/wc.svg
 create mode 120000 client/public/images/pieces/Pandemonium/wd.svg
 create mode 120000 client/public/images/pieces/Pandemonium/wg.svg
 create mode 120000 client/public/images/pieces/Pandemonium/wh.svg
 create mode 120000 client/public/images/pieces/Pandemonium/wm.svg
 create mode 120000 client/public/images/pieces/Pandemonium/ws.svg
 create mode 120000 client/public/images/pieces/Pandemonium/ww.svg
 create mode 100644 client/src/translations/rules/Pandemonium/en.pug
 create mode 100644 client/src/translations/rules/Pandemonium/es.pug
 create mode 100644 client/src/translations/rules/Pandemonium/fr.pug
 create mode 100644 client/src/variants/Pandemonium.js

diff --git a/client/public/images/pieces/Pandemonium/ba.svg b/client/public/images/pieces/Pandemonium/ba.svg
new file mode 120000
index 00000000..c301d868
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/ba.svg
@@ -0,0 +1 @@
+../bq.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/bc.svg b/client/public/images/pieces/Pandemonium/bc.svg
new file mode 120000
index 00000000..78e54f8d
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/bc.svg
@@ -0,0 +1 @@
+../Perfect/bs.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/bd.svg b/client/public/images/pieces/Pandemonium/bd.svg
new file mode 120000
index 00000000..09e6ea3e
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/bd.svg
@@ -0,0 +1 @@
+../Alice/bu.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/bg.svg b/client/public/images/pieces/Pandemonium/bg.svg
new file mode 120000
index 00000000..c301d868
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/bg.svg
@@ -0,0 +1 @@
+../bq.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/bh.svg b/client/public/images/pieces/Pandemonium/bh.svg
new file mode 120000
index 00000000..b30a26ad
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/bh.svg
@@ -0,0 +1 @@
+../Alice/bc.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/bm.svg b/client/public/images/pieces/Pandemonium/bm.svg
new file mode 120000
index 00000000..d3aaacf7
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/bm.svg
@@ -0,0 +1 @@
+../Perfect/be.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/bs.svg b/client/public/images/pieces/Pandemonium/bs.svg
new file mode 120000
index 00000000..1200186b
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/bs.svg
@@ -0,0 +1 @@
+../Alice/bo.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/bw.svg b/client/public/images/pieces/Pandemonium/bw.svg
new file mode 120000
index 00000000..c301d868
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/bw.svg
@@ -0,0 +1 @@
+../bq.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/wa.svg b/client/public/images/pieces/Pandemonium/wa.svg
new file mode 120000
index 00000000..aed155fe
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/wa.svg
@@ -0,0 +1 @@
+../wq.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/wc.svg b/client/public/images/pieces/Pandemonium/wc.svg
new file mode 120000
index 00000000..b0eb8b97
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/wc.svg
@@ -0,0 +1 @@
+../Perfect/ws.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/wd.svg b/client/public/images/pieces/Pandemonium/wd.svg
new file mode 120000
index 00000000..c1403b33
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/wd.svg
@@ -0,0 +1 @@
+../Alice/wu.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/wg.svg b/client/public/images/pieces/Pandemonium/wg.svg
new file mode 120000
index 00000000..aed155fe
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/wg.svg
@@ -0,0 +1 @@
+../wq.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/wh.svg b/client/public/images/pieces/Pandemonium/wh.svg
new file mode 120000
index 00000000..d23af91d
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/wh.svg
@@ -0,0 +1 @@
+../Alice/wc.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/wm.svg b/client/public/images/pieces/Pandemonium/wm.svg
new file mode 120000
index 00000000..f47feb0e
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/wm.svg
@@ -0,0 +1 @@
+../Perfect/we.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/ws.svg b/client/public/images/pieces/Pandemonium/ws.svg
new file mode 120000
index 00000000..4a85712d
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/ws.svg
@@ -0,0 +1 @@
+../Alice/wo.svg
\ No newline at end of file
diff --git a/client/public/images/pieces/Pandemonium/ww.svg b/client/public/images/pieces/Pandemonium/ww.svg
new file mode 120000
index 00000000..aed155fe
--- /dev/null
+++ b/client/public/images/pieces/Pandemonium/ww.svg
@@ -0,0 +1 @@
+../wq.svg
\ No newline at end of file
diff --git a/client/src/translations/en.js b/client/src/translations/en.js
index ca3b13a6..4d93adc7 100644
--- a/client/src/translations/en.js
+++ b/client/src/translations/en.js
@@ -269,6 +269,7 @@ export const translations = {
   "New fairy pieces": "New fairy pieces",
   "No paralyzed pieces": "No paralyzed pieces",
   "No-check mode": "No-check mode",
+  "Noise and confusion": "Noise and confusion",
   "Non-conformism and utopia": "Non-conformism and utopia",
   "Occupy the enemy palace": "Occupy the enemy palace",
   "Paralyzed pieces": "Paralyzed pieces",
diff --git a/client/src/translations/es.js b/client/src/translations/es.js
index 30095bfe..a07a5c12 100644
--- a/client/src/translations/es.js
+++ b/client/src/translations/es.js
@@ -269,6 +269,7 @@ export const translations = {
   "New fairy pieces": "Nuevas piezas magicas",
   "No paralyzed pieces": "No piezas paralizadas",
   "No-check mode": "Modo sin jaque",
+  "Noise and confusion": "Ruido y confusión",
   "Non-conformism and utopia": "No-conformismo y utopía",
   "Occupy the enemy palace": "Ocupar el palacio enemigo",
   "Paralyzed pieces": "Piezas paralizadas",
diff --git a/client/src/translations/fr.js b/client/src/translations/fr.js
index 0ebc8175..247b46f0 100644
--- a/client/src/translations/fr.js
+++ b/client/src/translations/fr.js
@@ -269,6 +269,7 @@ export const translations = {
   "New fairy pieces": "Nouvelles pièces féériques",
   "No paralyzed pieces": "Pas de pièces paralysées",
   "No-check mode": "Mode sans échec",
+  "Noise and confusion": "Bruit et confusion",
   "Non-conformism and utopia": "Non-conformisme et utopie",
   "Occupy the enemy palace": "Occuper le palais ennemi",
   "Paralyzed pieces": "Pièces paralysées",
diff --git a/client/src/translations/rules/Pandemonium/en.pug b/client/src/translations/rules/Pandemonium/en.pug
new file mode 100644
index 00000000..f5d518d6
--- /dev/null
+++ b/client/src/translations/rules/Pandemonium/en.pug
@@ -0,0 +1,63 @@
+p.boxed
+  | All pieces can promote. Captured units can be dropped later.
+  | 10x10 board. Some new pieces.
+
+figure.diagram-container
+  .diagram
+    | fen:rnbqkmcbnr/pppppppppp/91/91/91/91/91/91/PPPPPPPPPP/RNBQKMCBNR:
+  figcaption Initial deterministic position.
+
+p.
+  At the very first move, players may decide to swap positions of adjacent
+  knights and bishops. Either on both sides, or on one only. To bypass this
+  step (or end it after a first swap), move your king to the opponent's king.
+
+figure.showPieces.text-center
+  img(src="/images/pieces/Pandemonium/wc.svg" style="width:60px")
+  img(src="/images/pieces/Pandemonium/bm.svg" style="width:60px")
+  figcaption Cardinal = Bishop + Knight, Marshal = Rook + Knight.
+
+p.
+  Known pieces move as usual, with one exception: the pawn only promotes
+  to a queen (named "Gilding" in this game). Additionally, all pieces can
+  promote &mdash; except queen and king:
+ul
+  li Rook promotes into Dragon = Rook + King.
+  li Knight promotes into Scepter = Knight + King.
+  li Bishop promotes into Horse = Bishop + King.
+  li Cardinal promotes into Queen (called "Whole" here).
+  li Marshal promotes into Queen (called "Apricot" here).
+p.
+  All these promotions are optional. They are available after a move ending
+  at or starting from the last rank.
+
+p.
+  Each captured piece is first returned to its unpromoted version (if
+  applicable), and then added to a reserve. It can be dropped later
+  in place of a move.
+
+h3 Some details
+
+p.
+  Pawns can initially advance three squares.
+  On the third rank, they can still advance two squares.
+  A dropped pawn cannot give checkmate.
+
+p.
+  While castling, the king moves three squares lateraly.
+  Castling is possible even if the king or the rooks moved.
+  However, it can only be done once.
+
+p.
+  If after a move both kings are facing each other (on a rank or file)
+  without intervening pieces, then the player who made the move loses.
+
+h3 More information
+
+p
+  | See the 
+  a(href="https://www.chessvariants.com/rules/pandemonium")
+    | chessvariants page
+  | .
+
+p Inventor: Daphne Snowmoon (2020).
diff --git a/client/src/translations/rules/Pandemonium/es.pug b/client/src/translations/rules/Pandemonium/es.pug
new file mode 100644
index 00000000..8aed7fe1
--- /dev/null
+++ b/client/src/translations/rules/Pandemonium/es.pug
@@ -0,0 +1,65 @@
+p.boxed
+  | Todas las piezas pueden promocionarse. Las unidades capturadas son
+  | en paracaídas más tarde. Tablero de ajedrez 10x10. Algunas piezas nuevas.
+
+figure.diagram-container
+  .diagram
+    | fen:rnbqkmcbnr/pppppppppp/91/91/91/91/91/91/PPPPPPPPPP/RNBQKMCBNR:
+  figcaption Posición inicial determinista.
+
+p.
+  En el primer movimiento, los jugadores pueden decidir intercambiar
+  posiciones de caballos y alfiles adyacentes. O en ambos lados o solo en uno.
+  Para omitir este paso (o finalizar después de un primer intercambio),
+  lleva a tu rey al rey contrario.
+
+figure.showPieces.text-center
+  img(src="/images/pieces/Pandemonium/wc.svg" style="width:60px")
+  img(src="/images/pieces/Pandemonium/bm.svg" style="width:60px")
+  figcaption Cardenal = Alfil + Caballo, Mariscal = Torre + Caballo.
+
+p.
+  Las piezas conocidas se mueven como de costumbre, con una excepción:
+  los peones solo se promueven en una reina (llamado "Gilding" en este juego).
+  Además, todas las piezas pueden promocionarse &mdash; excepto rey y reina:
+ul
+  li Tower ascendido a Dragón = Torre + Rey.
+  li Caballo ascendido a Cetro = Cavalier + Rey.
+  li Alfil ascendido a Jinete = Alfil + Rey.
+  li Cardenal ascendido a Dama (llamado "Whole" aquí).
+  li Mariscal ascendió a Dama (aquí se llama "Apricot").
+p.
+  Todas estas promociones son opcionales. Están disponibles después de un
+  movimiento que termina o comienza en la última fila.
+
+p.
+  Cada pieza capturada se devuelve primero a su forma no promocionada (el caso
+  aplicable), luego se agrega a una reserva. Se puede lanzar en paracaídas
+  más tarde en lugar de una jugada.
+
+h3 Algunos detalles.
+
+p.
+  Los peones pueden avanzar inicialmente tres espacios.
+  En la tercera fila, todavía pueden avanzar dos espacios.
+  Un peón lanzado en paracaídas no puede dar jaque mate.
+
+p.
+  Durante el enroque, el rey mueve tres casillas hacia los lados.
+  El enroque es posible incluso si el rey o las torres se han movido.
+  Sin embargo, solo se puede realizar una vez.
+
+p.
+  Si después de una jugada los dos reyes se encuentran cara a cara (en fila
+  o una columna) sin piezas intermedias, entonces el jugador que hizo
+  el movimiento pierde.
+
+h3 Más información
+
+p
+  | Ver la 
+  a(href="https://www.chessvariants.com/rules/pandemonium")
+    | página chessvariants
+  | .
+
+p Inventor: Daphne Snowmoon (2020).
diff --git a/client/src/translations/rules/Pandemonium/fr.pug b/client/src/translations/rules/Pandemonium/fr.pug
new file mode 100644
index 00000000..bdd6d3b5
--- /dev/null
+++ b/client/src/translations/rules/Pandemonium/fr.pug
@@ -0,0 +1,65 @@
+p.boxed
+  | Toutes les pièces peuvent être promues. Les unités capturées sont
+  | parachutées plus tard. Échiquier 10x10. Quelques nouvelles pièces.
+
+figure.diagram-container
+  .diagram
+    | fen:rnbqkmcbnr/pppppppppp/91/91/91/91/91/91/PPPPPPPPPP/RNBQKMCBNR:
+  figcaption Position initiale déterministe.
+
+p.
+  Au tout premier coup, les joueurs peuvent décider d'échanger les positions
+  de cavaliers et fous adjacents. Soit des deux côtés, soit d'un seul.
+  Pour sauter cette étape (ou terminer après un premier échange),
+  amenez votre roi sur le roi adverse.
+
+figure.showPieces.text-center
+  img(src="/images/pieces/Pandemonium/wc.svg" style="width:60px")
+  img(src="/images/pieces/Pandemonium/bm.svg" style="width:60px")
+  figcaption Cardinal = Fou + Cavalier, Maréchal = Tour + Cavalier.
+
+p.
+  Les pièces connues se déplacent comme d'habitude, à une exception près :
+  les pions ne se promeuvent qu'en dame (appelée "Gilding" dans ce jeu).
+  De plus, toutes les pièces peuvent se promouvoir &mdash; sauf roi et dame :
+ul
+  li Tour promue en Dragon = Tour + Roi.
+  li Cavalier promu en Sceptre = Cavalier + Roi.
+  li Fou promu en Cheval = Fou + Roi.
+  li Cardinal promu en Dame (appelée "Whole" ici).
+  li Maréchal promu en Dame (appelée "Apricot" ici).
+p.
+  Toutes ces promotions sont optionnelles. Elles sont disponibles après un
+  coup terminant ou commençant sur la dernière rangée.
+
+p.
+  Chaque pièce capturée est d'abord ramenée à sa forme non promue (le cas
+  échéant), puis ajoutée à une réserve. Elle peut être parachutée plus tard
+  à la place d'un coup.
+
+h3 Quelques détails.
+
+p.
+  Les pions peuvent initialement avancer de trois cases.
+  Sur la troisième rangée, ils peuvent encore avancer de deux cases.
+  Un pion parachuté ne peut pas donner échec et mat.
+
+p.
+  Lors du roque, le roi se déplace de trois cases latéralement.
+  Le roque est possible même si le roi ou les tours ont bougé.
+  Cependant, il ne peut être exécuté qu'une fois.
+
+p.
+  Si après un coup les deux rois se retrouvent face à face (sur une rangée
+  ou une colonne) sans pièces intermédiaires, alors le joueur ayant effectué
+  le coup perd.
+
+h3 Plus d'information
+
+p
+  | Voir la 
+  a(href="https://www.chessvariants.com/rules/pandemonium")
+    | page chessvariants
+  | .
+
+p Inventeur : Daphne Snowmoon (2020).
diff --git a/client/src/translations/variants/en.pug b/client/src/translations/variants/en.pug
index eed4c980..966f96f5 100644
--- a/client/src/translations/variants/en.pug
+++ b/client/src/translations/variants/en.pug
@@ -471,6 +471,7 @@ p.
     "Iceage",
     "Kingsmaker",
     "Magnetic",
+    "Pandemonium",
     "Refusal",
     "Relayup",
     "Rollerball",
diff --git a/client/src/translations/variants/es.pug b/client/src/translations/variants/es.pug
index 01efa971..90196f68 100644
--- a/client/src/translations/variants/es.pug
+++ b/client/src/translations/variants/es.pug
@@ -481,6 +481,7 @@ p.
     "Iceage",
     "Kingsmaker",
     "Magnetic",
+    "Pandemonium",
     "Refusal",
     "Relayup",
     "Rollerball",
diff --git a/client/src/translations/variants/fr.pug b/client/src/translations/variants/fr.pug
index 3566c882..7729aaf0 100644
--- a/client/src/translations/variants/fr.pug
+++ b/client/src/translations/variants/fr.pug
@@ -479,6 +479,7 @@ p.
     "Iceage",
     "Kingsmaker",
     "Magnetic",
+    "Pandemonium",
     "Refusal",
     "Relayup",
     "Rollerball",
diff --git a/client/src/variants/Omega.js b/client/src/variants/Omega.js
index a4276ed7..a688a2ea 100644
--- a/client/src/variants/Omega.js
+++ b/client/src/variants/Omega.js
@@ -309,18 +309,12 @@ export class OmegaRules extends ChessRules {
     return moves;
   }
 
-  addPawnMoves([x1, y1], [x2, y2], moves, promotions) {
-    let finalPieces = [V.PAWN];
+  addPawnMoves([x1, y1], [x2, y2], moves) {
     const color = this.turn;
     const lastRank = (color == "w" ? 1 : V.size.x - 2);
-    if (x2 == lastRank) {
-      // promotions arg: special override for Hiddenqueen variant
-      if (!!promotions) finalPieces = promotions;
-      else if (!!V.PawnSpecs.promotions) finalPieces = V.PawnSpecs.promotions;
-    }
-    let tr = null;
+    const finalPieces = (x2 == lastRank ? V.PawnSpecs.promotions : [V.PAWN]);
     for (let piece of finalPieces) {
-      tr = (piece != V.PAWN ? { c: color, p: piece } : null);
+      const tr = (piece != V.PAWN ? { c: color, p: piece } : null);
       moves.push(this.getBasicMove([x1, y1], [x2, y2], tr));
     }
   }
diff --git a/client/src/variants/Pandemonium.js b/client/src/variants/Pandemonium.js
new file mode 100644
index 00000000..34dc77e1
--- /dev/null
+++ b/client/src/variants/Pandemonium.js
@@ -0,0 +1,785 @@
+import { ChessRules, Move, PiPo } from "@/base_rules";
+import { randInt } from "@/utils/alea";
+
+export class PandemoniumRules extends ChessRules {
+
+  static get PawnSpecs() {
+    return Object.assign(
+      {},
+      ChessRules.PawnSpecs,
+      {
+        threeSquares: true,
+        promotions: [V.GILDING]
+      }
+    );
+  }
+
+  static get GILDING() {
+    return "g";
+  }
+
+  static get SCEPTER() {
+    return "s";
+  }
+
+  static get HORSE() {
+    return "h";
+  }
+
+  static get DRAGON() {
+    return "d";
+  }
+
+  static get CARDINAL() {
+    return "c";
+  }
+
+  static get WHOLE() {
+    return "w";
+  }
+
+  static get MARSHAL() {
+    return "m";
+  }
+
+  static get APRICOT() {
+    return "a";
+  }
+
+  static get PIECES() {
+    return (
+      ChessRules.PIECES.concat([
+        V.GILDING, V.SCEPTER, V.HORSE, V.DRAGON,
+        V.CARDINAL, V.WHOLE, V.MARSHAL, V.APRICOT])
+    );
+  }
+
+  getPpath(b) {
+    const prefix = (ChessRules.PIECES.includes(b[1]) ? "" : "Pandemonium/");
+    return prefix + b;
+  }
+
+  static get size() {
+    return { x: 10, y: 10};
+  }
+
+  getColor(i, j) {
+    if (i >= V.size.x) return i == V.size.x ? "w" : "b";
+    return this.board[i][j].charAt(0);
+  }
+
+  getPiece(i, j) {
+    if (i >= V.size.x) return V.RESERVE_PIECES[j];
+    return this.board[i][j].charAt(1);
+  }
+
+  setOtherVariables(fen) {
+    super.setOtherVariables(fen);
+    // Sub-turn is useful only at first move...
+    this.subTurn = 1;
+    // 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]: reserve[0],
+        [V.ROOK]: reserve[1],
+        [V.KNIGHT]: reserve[2],
+        [V.BISHOP]: reserve[3],
+        [V.QUEEN]: reserve[4],
+        [V.CARDINAL]: reserve[5],
+        [V.MARSHAL]: reserve[6],
+      },
+      b: {
+        [V.PAWN]: reserve[7],
+        [V.ROOK]: reserve[8],
+        [V.KNIGHT]: reserve[9],
+        [V.BISHOP]: reserve[10],
+        [V.QUEEN]: reserve[11],
+        [V.CARDINAL]: reserve[12],
+        [V.MARSHAL]: reserve[13]
+      }
+    };
+  }
+
+  static IsGoodEnpassant(enpassant) {
+    if (enpassant != "-") {
+      const squares = enpassant.split(",");
+      if (squares.length > 2) return false;
+      for (let sq of squares) {
+        if (!sq.match(/[a-j0-9]/)) return false;
+      }
+    }
+    return true;
+  }
+
+  static IsGoodFen(fen) {
+    if (!ChessRules.IsGoodFen(fen)) return false;
+    const fenParsed = V.ParseFen(fen);
+    // Check reserves
+    if (!fenParsed.reserve || !fenParsed.reserve.match(/^[0-9]{14,14}$/))
+      return false;
+    return true;
+  }
+
+  static ParseFen(fen) {
+    const fenParts = fen.split(" ");
+    return Object.assign(
+      ChessRules.ParseFen(fen),
+      { reserve: fenParts[5] }
+    );
+  }
+
+  getFen() {
+    return super.getFen() + " " + this.getReserveFen();
+  }
+
+  getFenForRepeat() {
+    return super.getFenForRepeat() + "_" + this.getReserveFen();
+  }
+
+  getReserveFen() {
+    let counts = new Array(14);
+    for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
+      counts[i] = this.reserve["w"][V.RESERVE_PIECES[i]];
+      counts[7 + i] = this.reserve["b"][V.RESERVE_PIECES[i]];
+    }
+    return counts.join("");
+  }
+
+  setFlags(fenflags) {
+    // white a-castle, h-castle, king pos, then same for black.
+    this.castleFlags = { w: [-1, -1, -1], b: [-1, -1, -1] };
+    for (let i = 0; i < 6; i++) {
+      this.castleFlags[i < 3 ? "w" : "b"][i % 3] =
+        V.ColumnToCoord(fenflags.charAt(i));
+    }
+  }
+
+  static GenRandInitFen(randomness) {
+    // No randomization here for now (but initial setup choice)
+    return (
+      "rnbqkmcbnr/pppppppppp/91/91/91/91/91/91/PPPPPPPPPP/RNBQKMCBNR " +
+      "w 0 ajeaje - 00000000000000"
+    );
+    // TODO later: randomization too --> 2 bishops, not next to each other.
+    // then knights next to bishops. Then other pieces (...).
+  }
+
+  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
+  }
+
+  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
+  }
+
+  getReservePpath(index, color) {
+    const p = V.RESERVE_PIECES[index];
+    const prefix = (ChessRules.PIECES.includes(p) ? "" : "Pandemonium/");
+    return prefix + color + p;;
+  }
+
+  // Ordering on reserve pieces
+  static get RESERVE_PIECES() {
+    return (
+      [V.PAWN, V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN, V.CARDINAL, V.MARSHAL]
+    );
+  }
+
+  getReserveMoves([x, y]) {
+    const color = this.turn;
+    const p = V.RESERVE_PIECES[y];
+    if (this.reserve[color][p] == 0) return [];
+    const bounds = (p == V.PAWN ? [1, V.size.x - 1] : [0, V.size.x]);
+    let moves = [];
+    for (let i = bounds[0]; i < bounds[1]; i++) {
+      for (let j = 0; j < V.size.y; j++) {
+        if (this.board[i][j] == V.EMPTY) {
+          let mv = new Move({
+            appear: [
+              new PiPo({
+                x: i,
+                y: j,
+                c: color,
+                p: p
+              })
+            ],
+            vanish: [],
+            start: { x: x, y: y }, //a bit artificial...
+            end: { x: i, y: j }
+          });
+          if (p == V.PAWN) {
+            // Do not drop on checkmate:
+            this.play(mv);
+            const res = (
+              this.underCheck(oppCol) && !this.atLeastOneMove("noReserve")
+            );
+            this.undo(mv);
+            if (res) continue;
+          }
+          moves.push(mv);
+        }
+      }
+    }
+    return moves;
+  }
+
+  static get PromoteMap() {
+    return {
+      r: 'd',
+      n: 's',
+      b: 'h',
+      c: 'w',
+      m: 'a'
+    };
+  }
+
+  getPotentialMovesFrom([x, y]) {
+    const c = this.getColor(x, y);
+    const oppCol = V.GetOppCol(c);
+    if (this.movesCount <= 1) {
+      if (this.kingPos[c][0] == x && this.kingPos[c][1] == y) {
+        // Pass (if setup is ok)
+        return [
+          new Move({
+            appear: [],
+            vanish: [],
+            start: { x: this.kingPos[c][0], y: this.kingPos[c][1] },
+            end: { x: this.kingPos[oppCol][0], y: this.kingPos[oppCol][1] }
+          })
+        ];
+      }
+      const firstRank = (this.movesCount == 0 ? 9 : 0);
+      // TODO: initDestFile currently hardcoded for deterministic setup
+      const initDestFile = new Map([[1, 2], [8, 7]]);
+      // Only option is knight / bishop swap:
+      if (x == firstRank && !!initDestFile.get(y)) {
+        const destFile = initDestFile.get(y);
+        return [
+          new Move({
+            appear: [
+              new PiPo({
+                x: x,
+                y: destFile,
+                c: c,
+                p: V.KNIGHT
+              }),
+              new PiPo({
+                x: x,
+                y: y,
+                c: c,
+                p: V.BISHOP
+              })
+            ],
+            vanish: [
+              new PiPo({
+                x: x,
+                y: y,
+                c: c,
+                p: V.KNIGHT
+              }),
+              new PiPo({
+                x: x,
+                y: destFile,
+                c: c,
+                p: V.BISHOP
+              })
+            ],
+            start: { x: x, y: y },
+            end: { x: x, y: destFile }
+          })
+        ];
+      }
+      return [];
+    }
+    // Normal move (after initial setup)
+    if (x >= V.size.x) return this.getReserveMoves(x, y);
+    const p = this.getPiece(x, y);
+    const sq = [x, y];
+    let moves = [];
+    if (ChessRules.PIECES.includes(p))
+      moves = super.getPotentialMovesFrom(sq);
+    if ([V.GILDING, V.APRICOT, V.WHOLE].includes(p))
+      moves = super.getPotentialQueenMoves(sq);
+    switch (p) {
+      case V.SCEPTER:
+        moves = this.getPotentialScepterMoves(sq);
+        break;
+      case V.HORSE:
+        moves = this.getPotentialHorseMoves(sq);
+        break;
+      case V.DRAGON:
+        moves = this.getPotentialDragonMoves(sq);
+        break;
+      case V.CARDINAL:
+        moves = this.getPotentialCardinalMoves(sq);
+        break;
+      case V.MARSHAL:
+        moves = this.getPotentialMarshalMoves(sq);
+        break;
+    }
+    // Maybe apply promotions:
+    if (Object.keys(V.PromoteMap).includes(p)) {
+      const promoted = V.PromoteMap[p];
+      const lastRank = (c == 'w' ? 0 : 9);
+      let promotions = [];
+      moves.forEach(m => {
+        if (m.start.x == lastRank || m.end.x == lastRank) {
+          let pMove = JSON.parse(JSON.stringify(m));
+          pMove.appear[0].p = promoted;
+          promotions.push(pMove);
+        }
+      });
+      Array.prototype.push.apply(moves, promotions);
+    }
+    return moves;
+  }
+
+  getPotentialPawnMoves([x, y]) {
+    const color = this.turn;
+    const shiftX = V.PawnSpecs.directions[color];
+    let moves = [];
+    if (this.board[x + shiftX][y] == V.EMPTY) {
+      this.addPawnMoves([x, y], [x + shiftX, y], moves);
+      if ((color == 'w' && x >= V.size.x - 3) || (color == 'b' && x <= 3)) {
+        if (this.board[x + 2 * shiftX][y] == V.EMPTY) {
+          moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
+          if (
+            (
+              (color == 'w' && x >= V.size.x - 2) ||
+              (color == 'b' && x <= 2)
+            )
+            &&
+            this.board[x + 3 * shiftX][y] == V.EMPTY
+          ) {
+            moves.push(this.getBasicMove([x, y], [x + 3 * shiftX, y]));
+          }
+        }
+      }
+    }
+    for (let shiftY of [-1, 1]) {
+      if (y + shiftY >= 0 && y + shiftY < V.size.y) {
+        if (
+          this.board[x + shiftX][y + shiftY] != V.EMPTY &&
+          this.canTake([x, y], [x + shiftX, y + shiftY])
+        ) {
+          this.addPawnMoves([x, y], [x + shiftX, y + shiftY], moves);
+        }
+      }
+    }
+    Array.prototype.push.apply(
+      moves,
+      this.getEnpassantCaptures([x, y], shiftX)
+    );
+    return moves;
+  }
+
+  getPotentialMarshalMoves(sq) {
+    return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
+      this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
+    );
+  }
+
+  getPotentialCardinalMoves(sq) {
+    return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat(
+      this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
+    );
+  }
+
+  getPotentialScepterMoves(sq) {
+    const steps =
+      V.steps[V.KNIGHT].concat(V.steps[V.BISHOP]).concat(V.steps[V.ROOK]);
+    return this.getSlideNJumpMoves(sq, steps, "oneStep");
+  }
+
+  getPotentialHorseMoves(sq) {
+    return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat(
+      this.getSlideNJumpMoves(sq, V.steps[V.ROOK], "oneStep"));
+  }
+
+  getPotentialDragonMoves(sq) {
+    return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
+      this.getSlideNJumpMoves(sq, V.steps[V.BISHOP], "oneStep"));
+  }
+
+  getEnpassantCaptures([x, y], shiftX) {
+    const Lep = this.epSquares.length;
+    const epSquare = this.epSquares[Lep - 1];
+    let moves = [];
+    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);
+        }
+      }
+    }
+    return moves;
+  }
+
+  getPotentialKingMoves(sq) {
+    // Initialize with normal moves
+    let moves = this.getSlideNJumpMoves(
+      sq,
+      V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
+      "oneStep"
+    );
+    const c = this.turn;
+    if (
+      this.castleFlags[c][0] < V.size.y ||
+      this.castleFlags[c][1] < V.size.y
+    ) {
+      moves = moves.concat(this.getCastleMoves(sq));
+    }
+    return moves;
+  }
+
+  getCastleMoves([x, y]) {
+    const c = this.getColor(x, y);
+    if (
+      ((c == 'w' && x == 9) || (c == 'b' && x == 0)) &&
+      y == this.castleFlags[c][2]
+    ) {
+      const finalSquares = [
+        [1, 2],
+        [7, 6]
+      ];
+      return super.getCastleMoves([x, y], finalSquares, false, [V.ROOK]);
+    }
+    return [];
+  }
+
+  isAttacked(sq, color) {
+    return (
+      this.isAttackedByPawn(sq, color) ||
+      this.isAttackedByRook(sq, color) ||
+      this.isAttackedByKnight(sq, color) ||
+      this.isAttackedByBishop(sq, color) ||
+      this.isAttackedByKing(sq, color) ||
+      this.isAttackedByQueens(sq, color) ||
+      this.isAttackedByScepter(sq, color) ||
+      this.isAttackedByDragon(sq, color) ||
+      this.isAttackedByHorse(sq, color) ||
+      this.isAttackedByMarshal(sq, color) ||
+      this.isAttackedByCardinal(sq, color)
+    );
+  }
+
+  isAttackedByQueens([x, y], color) {
+    // pieces: because queen = gilding = whole = apricot
+    const pieces = [V.QUEEN, V.GILDING, V.WHOLE, V.APRICOT];
+    const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
+    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) {
+        rx += step[0];
+        ry += step[1];
+      }
+      if (
+        V.OnBoard(rx, ry) &&
+        this.board[rx][ry] != V.EMPTY &&
+        pieces.includes(this.getPiece(rx, ry)) &&
+        this.getColor(rx, ry) == color
+      ) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  isAttackedByScepter(sq, color) {
+    const steps =
+      V.steps[V.KNIGHT].concat(V.steps[V.ROOK]).concat(V.steps[V.BISHOP]);
+    return (
+      super.isAttackedBySlideNJump(sq, color, steps, V.SCEPTER, "oneStep")
+    );
+  }
+
+  isAttackedByHorse(sq, color) {
+    return (
+      super.isAttackedBySlideNJump(sq, color, V.steps[V.BISHOP], V.HORSE) ||
+      super.isAttackedBySlideNJump(
+        sq, color, V.steps[V.ROOK], V.HORSE, "oneStep")
+    );
+  }
+
+  isAttackedByDragon(sq, color) {
+    return (
+      super.isAttackedBySlideNJump(sq, color, V.steps[V.ROOK], V.DRAGON) ||
+      super.isAttackedBySlideNJump(
+        sq, color, V.steps[V.BISHOP], V.DRAGON, "oneStep")
+    );
+  }
+
+  isAttackedByMarshal(sq, color) {
+    return (
+      super.isAttackedBySlideNJump(sq, color, V.MARSHAL, V.steps[V.ROOK]) ||
+      super.isAttackedBySlideNJump(
+        sq,
+        color,
+        V.MARSHAL,
+        V.steps[V.KNIGHT],
+        "oneStep"
+      )
+    );
+  }
+
+  isAttackedByCardinal(sq, color) {
+    return (
+      super.isAttackedBySlideNJump(sq, color, V.CARDINAL, V.steps[V.BISHOP]) ||
+      super.isAttackedBySlideNJump(
+        sq,
+        color,
+        V.CARDINAL,
+        V.steps[V.KNIGHT],
+        "oneStep"
+      )
+    );
+  }
+
+  getAllValidMoves() {
+    let moves = super.getAllPotentialMoves();
+    const color = this.turn;
+    for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
+      moves = moves.concat(
+        this.getReserveMoves([V.size.x + (color == "w" ? 0 : 1), i])
+      );
+    }
+    return this.filterValid(moves);
+  }
+
+  atLeastOneMove(noReserve) {
+    if (!super.atLeastOneMove()) {
+      if (!noReserve) {
+        // Search one reserve move
+        for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
+          let moves = this.filterValid(
+            this.getReserveMoves([V.size.x + (this.turn == "w" ? 0 : 1), i])
+          );
+          if (moves.length > 0) return true;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+
+  // Reverse 'PromoteMap'
+  static get P_CORRESPONDANCES() {
+    return {
+      d: 'r',
+      s: 'n',
+      h: 'b',
+      w: 'c',
+      a: 'm'
+    };
+  }
+
+  static MayDecode(piece) {
+    if (Object.keys(V.P_CORRESPONDANCES).includes(piece))
+      return V.P_CORRESPONDANCES[piece];
+    return piece;
+  }
+
+  play(move) {
+    move.subTurn = this.subTurn; //much easier
+    if (this.movesCount >= 2 || this.subTurn == 2 || move.vanish.length == 0) {
+      this.turn = V.GetOppCol(this.turn);
+      this.subTurn = 1;
+      this.movesCount++;
+    }
+    else this.subTurn = 2;
+    move.flags = JSON.stringify(this.aggregateFlags());
+    this.epSquares.push(this.getEpSquare(move));
+    V.PlayOnBoard(this.board, move);
+    this.postPlay(move);
+  }
+
+  updateCastleFlags(move, piece) {
+    if (move.appear.length == 2) {
+      // Castling (only move which disable flags)
+      this.castleFlags[move.appear[0].c][0] = 10;
+      this.castleFlags[move.appear[0].c][1] = 10;
+    }
+  }
+
+  postPlay(move) {
+    if (move.vanish.length == 0 && move.appear.length == 0) return;
+    super.postPlay(move);
+    const color = move.appear[0].c;
+    if (move.vanish.length == 0)
+      // Drop unpromoted piece:
+      this.reserve[color][move.appear[0].p]--;
+    else if (move.vanish.length == 2)
+      // May capture a promoted piece:
+      this.reserve[color][V.MayDecode(move.vanish[1].p)]++;
+  }
+
+  undo(move) {
+    this.epSquares.pop();
+    this.disaggregateFlags(JSON.parse(move.flags));
+    V.UndoOnBoard(this.board, move);
+    if (this.movesCount >= 2 || this.subTurn == 1 || move.vanish.length == 0) {
+      this.turn = V.GetOppCol(this.turn);
+      this.movesCount--;
+    }
+    this.subTurn = move.subTurn;
+    this.postUndo(move);
+  }
+
+  postUndo(move) {
+    if (move.vanish.length == 0 && move.appear.length == 0) return;
+    super.postUndo(move);
+    const color = move.appear[0].c;
+    if (move.vanish.length == 0)
+      this.reserve[color][move.appear[0].p]++;
+    else if (move.vanish.length == 2)
+      this.reserve[color][V.MayDecode(move.vanish[1].p)]--;
+  }
+
+  getCurrentScore() {
+    const c = this.turn,
+          oppCol = V.GetOppCol(this.turn);
+    let facingKings = false;
+    if (
+      this.kingPos[c][0] == this.kingPos[oppCol][0] ||
+      this.kingPos[c][1] == this.kingPos[oppCol][1]
+    ) {
+      facingKings = true;
+      let step = [
+        this.kingPos[oppCol][0] - this.kingPos[c][0],
+        this.kingPos[oppCol][1] - this.kingPos[c][1]
+      ];
+      if (step[0] != 0) step[0] /= Math.abs(step[0]);
+      else step[1] /= Math.abs(step[1]);
+      let [x, y] =
+        [ this.kingPos[c][0] + step[0], this.kingPos[c][1] + step[1] ];
+      while (x != this.kingPos[oppCol][0] || y != this.kingPos[oppCol][1]) {
+        if (this.board[x][y] != V.EMPTY) {
+          facingKings = false;
+          break;
+        }
+        x += step[0];
+        y += step[1];
+      }
+    }
+    if (facingKings) return (c == "w" ? "1-0" : "0-1");
+    if (!this.atLeastOneMove()) return (c == "w" ? "0-1" : "1-0");
+    return "*";
+  }
+
+  static get VALUES() {
+    return Object.assign(
+      {
+        g: 9,
+        s: 5,
+        h: 6,
+        d: 7,
+        c: 7,
+        w: 9,
+        m: 8,
+        a: 9
+      },
+      ChessRules.VALUES
+    );
+  }
+
+  static get SEARCH_DEPTH() {
+    return 2;
+  }
+
+  getComputerMove() {
+    if (this.movesCount <= 1) {
+      // Special case: swap and pass at random
+      const moves1 = this.getAllValidMoves();
+      const m1 = moves1[randInt(moves1.length)];
+      this.play(m1);
+      if (m1.vanish.length == 0) {
+        this.undo(m1);
+        return m1;
+      }
+      const moves2 = this.getAllValidMoves();
+      const m2 = moves2[randInt(moves2.length)];
+      this.undo(m1);
+      return [m1, m2];
+    }
+    return super.getComputerMove();
+  }
+
+  evalPosition() {
+    let evaluation = super.evalPosition();
+    // Add reserves:
+    for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
+      const p = V.RESERVE_PIECES[i];
+      evaluation += this.reserve["w"][p] * V.VALUES[p];
+      evaluation -= this.reserve["b"][p] * V.VALUES[p];
+    }
+    return evaluation;
+  }
+
+  getNotation(move) {
+    if (move.vanish.length == 0) {
+      if (move.appear.length == 0) return "pass";
+      const pieceName =
+        (move.appear[0].p == V.PAWN ? "" : move.appear[0].p.toUpperCase());
+      return pieceName + "@" + V.CoordsToSquare(move.end);
+    }
+    if (move.appear.length == 2) {
+      if (move.appear[0].p != V.KING)
+        return V.CoordsToSquare(move.start) + "S" + V.CoordsToSquare(move.end);
+      return (move.end.y < move.start.y ? "0-0" : "0-0-0");
+    }
+    let notation = super.getNotation(move);
+    if (move.vanish[0].p != V.PAWN && move.appear[0].p != move.vanish[0].p)
+      // Add promotion indication:
+      notation += "=" + move.appear[0].p.toUpperCase();
+    return notation;
+  }
+
+};
diff --git a/client/src/variants/Shogi.js b/client/src/variants/Shogi.js
index 9104ed92..ac98835a 100644
--- a/client/src/variants/Shogi.js
+++ b/client/src/variants/Shogi.js
@@ -282,7 +282,9 @@ export class ShogiRules extends ChessRules {
           if (p == V.PAWN) {
             // Do not drop on checkmate:
             this.play(mv);
-            const res = (this.underCheck(oppCol) && !this.atLeastOneMove());
+            const res = (
+              this.underCheck(oppCol) && !this.atLeastOneMove("noReserve")
+            );
             this.undo(mv);
             if (res) continue;
           }
@@ -548,14 +550,16 @@ export class ShogiRules extends ChessRules {
     return this.filterValid(moves);
   }
 
-  atLeastOneMove() {
+  atLeastOneMove(noReserve) {
     if (!super.atLeastOneMove()) {
-      // Search one reserve move
-      for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
-        let moves = this.filterValid(
-          this.getReserveMoves([V.size.x + (this.turn == "w" ? 0 : 1), i])
-        );
-        if (moves.length > 0) return true;
+      if (!noReserve) {
+        // Search one reserve move
+        for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
+          let moves = this.filterValid(
+            this.getReserveMoves([V.size.x + (this.turn == "w" ? 0 : 1), i])
+          );
+          if (moves.length > 0) return true;
+        }
       }
       return false;
     }
diff --git a/server/db/populate.sql b/server/db/populate.sql
index f9c9a332..c08dc9e3 100644
--- a/server/db/populate.sql
+++ b/server/db/populate.sql
@@ -116,6 +116,7 @@ insert or ignore into Variants (name, description) values
   ('Pacifist1', 'Convert & support (v1)'),
   ('Pacifist2', 'Convert & support (v2)'),
   ('Pacosako', 'Dance with the King'),
+  ('Pandemonium', 'Noise and confusion'),
   ('Parachute', 'Landing on the board'),
   ('Pawnmassacre', 'Pieces upside down'),
   ('Pawns', 'Reach the last rank (v1)'),
-- 
2.44.0