From: Benjamin Auder <benjamin.auder@somewhere>
Date: Wed, 10 Apr 2019 14:42:39 +0000 (+0200)
Subject: Fixing computer play
X-Git-Url: https://git.auder.net/variants/current/doc/mini-custom.min.css?a=commitdiff_plain;h=1c9f093dad69e4c7b6d2b42cb5e0bd3bc7224ec9;p=vchess.git

Fixing computer play
---

diff --git a/client/src/base_rules.js b/client/src/base_rules.js
index bb2edc43..087b4f5b 100644
--- a/client/src/base_rules.js
+++ b/client/src/base_rules.js
@@ -6,1317 +6,1318 @@ import { random, sample, shuffle } from "@/utils/alea";
 
 export const PiPo = class PiPo //Piece+Position
 {
-	// o: {piece[p], color[c], posX[x], posY[y]}
-	constructor(o)
-	{
-		this.p = o.p;
-		this.c = o.c;
-		this.x = o.x;
-		this.y = o.y;
-	}
+  // o: {piece[p], color[c], posX[x], posY[y]}
+  constructor(o)
+  {
+    this.p = o.p;
+    this.c = o.c;
+    this.x = o.x;
+    this.y = o.y;
+  }
 }
 
 // TODO: for animation, moves should contains "moving" and "fading" maybe...
 export const Move = class Move
 {
-	// o: {appear, vanish, [start,] [end,]}
-	// appear,vanish = arrays of PiPo
-	// start,end = coordinates to apply to trigger move visually (think castle)
-	constructor(o)
-	{
-		this.appear = o.appear;
-		this.vanish = o.vanish;
-		this.start = !!o.start ? o.start : {x:o.vanish[0].x, y:o.vanish[0].y};
-		this.end = !!o.end ? o.end : {x:o.appear[0].x, y:o.appear[0].y};
-	}
+  // o: {appear, vanish, [start,] [end,]}
+  // appear,vanish = arrays of PiPo
+  // start,end = coordinates to apply to trigger move visually (think castle)
+  constructor(o)
+  {
+    this.appear = o.appear;
+    this.vanish = o.vanish;
+    this.start = !!o.start ? o.start : {x:o.vanish[0].x, y:o.vanish[0].y};
+    this.end = !!o.end ? o.end : {x:o.appear[0].x, y:o.appear[0].y};
+  }
 }
 
 // NOTE: x coords = top to bottom; y = left to right (from white player perspective)
 export const ChessRules = class ChessRules
 {
-	//////////////
-	// MISC UTILS
-
-	static get HasFlags() { return true; } //some variants don't have flags
-
-	static get HasEnpassant() { return true; } //some variants don't have ep.
-
-	// Path to pieces
-	static getPpath(b)
-	{
-		return b; //usual pieces in pieces/ folder
-	}
-
-	// Turn "wb" into "B" (for FEN)
-	static board2fen(b)
-	{
-		return b[0]=='w' ? b[1].toUpperCase() : b[1];
-	}
-
-	// Turn "p" into "bp" (for board)
-	static fen2board(f)
-	{
-		return f.charCodeAt()<=90 ? "w"+f.toLowerCase() : "b"+f;
-	}
-
-	// Check if FEN describe a position
-	static IsGoodFen(fen)
-	{
-		const fenParsed = V.ParseFen(fen);
-		// 1) Check position
-		if (!V.IsGoodPosition(fenParsed.position))
-			return false;
-		// 2) Check turn
-		if (!fenParsed.turn || !V.IsGoodTurn(fenParsed.turn))
-			return false;
-		// 3) Check moves count
-		if (!fenParsed.movesCount || !(parseInt(fenParsed.movesCount) >= 0))
-			return false;
-		// 4) Check flags
-		if (V.HasFlags && (!fenParsed.flags || !V.IsGoodFlags(fenParsed.flags)))
-			return false;
-		// 5) Check enpassant
-		if (V.HasEnpassant &&
-			(!fenParsed.enpassant || !V.IsGoodEnpassant(fenParsed.enpassant)))
-		{
-			return false;
-		}
-		return true;
-	}
-
-	// Is position part of the FEN a priori correct?
-	static IsGoodPosition(position)
-	{
-		if (position.length == 0)
-			return false;
-		const rows = position.split("/");
-		if (rows.length != V.size.x)
-			return false;
-		for (let row of rows)
-		{
-			let sumElts = 0;
-			for (let i=0; i<row.length; i++)
-			{
-				if (V.PIECES.includes(row[i].toLowerCase()))
-					sumElts++;
-				else
-				{
-					const num = parseInt(row[i]);
-					if (isNaN(num))
-						return false;
-					sumElts += num;
-				}
-			}
-			if (sumElts != V.size.y)
-				return false;
-		}
-		return true;
-	}
-
-	// For FEN checking
-	static IsGoodTurn(turn)
-	{
-		return ["w","b"].includes(turn);
-	}
-
-	// For FEN checking
-	static IsGoodFlags(flags)
-	{
-		return !!flags.match(/^[01]{4,4}$/);
-	}
-
-	static IsGoodEnpassant(enpassant)
-	{
-		if (enpassant != "-")
-		{
-			const ep = V.SquareToCoords(fenParsed.enpassant);
-			if (isNaN(ep.x) || !V.OnBoard(ep))
-				return false;
-		}
-		return true;
-	}
-
-	// 3 --> d (column number to letter)
-	static CoordToColumn(colnum)
-	{
-		return String.fromCharCode(97 + colnum);
-	}
-
-	// d --> 3 (column letter to number)
-	static ColumnToCoord(column)
-	{
-		return column.charCodeAt(0) - 97;
-	}
-
-	// a4 --> {x:3,y:0}
-	static SquareToCoords(sq)
-	{
-		return {
-			// NOTE: column is always one char => max 26 columns
-			// row is counted from black side => subtraction
-			x: V.size.x - parseInt(sq.substr(1)),
-			y: sq[0].charCodeAt() - 97
-		};
-	}
-
-	// {x:0,y:4} --> e8
-	static CoordsToSquare(coords)
-	{
-		return V.CoordToColumn(coords.y) + (V.size.x - coords.x);
-	}
-
-	// Aggregates flags into one object
-	aggregateFlags()
-	{
-		return this.castleFlags;
-	}
-
-	// Reverse operation
-	disaggregateFlags(flags)
-	{
-		this.castleFlags = flags;
-	}
-
-	// En-passant square, if any
-	getEpSquare(moveOrSquare)
-	{
-		if (!moveOrSquare)
-			return undefined;
-		if (typeof moveOrSquare === "string")
-		{
-			const square = moveOrSquare;
-			if (square == "-")
-				return undefined;
-			return V.SquareToCoords(square);
-		}
-		// Argument is a move:
-		const move = moveOrSquare;
-		const [sx,sy,ex] = [move.start.x,move.start.y,move.end.x];
-		// TODO: next conditions are first for Atomic, and third for Checkered
-		if (move.appear.length > 0 && move.appear[0].p == V.PAWN && ["w","b"].includes(move.appear[0].c) && Math.abs(sx - ex) == 2)
-		{
-			return {
-				x: (sx + ex)/2,
-				y: sy
-			};
-		}
-		return undefined; //default
-	}
-
-	// Can thing on square1 take thing on square2
-	canTake([x1,y1], [x2,y2])
-	{
-		return this.getColor(x1,y1) !== this.getColor(x2,y2);
-	}
-
-	// Is (x,y) on the chessboard?
-	static OnBoard(x,y)
-	{
-		return (x>=0 && x<V.size.x && y>=0 && y<V.size.y);
-	}
-
-	// Used in interface: 'side' arg == player color
-	canIplay(side, [x,y])
-	{
-		return (this.turn == side && this.getColor(x,y) == side);
-	}
-
-	// On which squares is color under check ? (for interface)
-	getCheckSquares(color)
-	{
-		return this.isAttacked(this.kingPos[color], [V.GetOppCol(color)])
-			? [JSON.parse(JSON.stringify(this.kingPos[color]))] //need to duplicate!
-			: [];
-	}
-
-	/////////////
-	// FEN UTILS
-
-	// Setup the initial random (assymetric) position
-	static GenRandInitFen()
-	{
-		let pieces = { "w": new Array(8), "b": new Array(8) };
-		// Shuffle pieces on first and last rank
-		for (let c of ["w","b"])
-		{
-			let positions = ArrayFun.range(8);
-
-			// Get random squares for bishops
-			let randIndex = 2 * random(4);
-			const bishop1Pos = positions[randIndex];
-			// The second bishop must be on a square of different color
-			let randIndex_tmp = 2 * random(4) + 1;
-			const 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 = random(6);
-			const knight1Pos = positions[randIndex];
-			positions.splice(randIndex, 1);
-			randIndex = random(5);
-			const knight2Pos = positions[randIndex];
-			positions.splice(randIndex, 1);
-
-			// Get random square for queen
-			randIndex = random(4);
-			const queenPos = positions[randIndex];
-			positions.splice(randIndex, 1);
-
-			// Rooks and king positions are now fixed,
-			// because of the ordering rook-king-rook
-			const rook1Pos = positions[0];
-			const kingPos = positions[1];
-			const rook2Pos = positions[2];
-
-			// 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';
-			pieces[c][kingPos] = 'k';
-			pieces[c][bishop2Pos] = 'b';
-			pieces[c][knight2Pos] = 'n';
-			pieces[c][rook2Pos] = 'r';
-		}
-		return pieces["b"].join("") +
-			"/pppppppp/8/8/8/8/PPPPPPPP/" +
-			pieces["w"].join("").toUpperCase() +
-			" w 0 1111 -"; //add turn + flags + enpassant
-	}
-
-	// "Parse" FEN: just return untransformed string data
-	static ParseFen(fen)
-	{
-		const fenParts = fen.split(" ");
-		let res =
-		{
-			position: fenParts[0],
-			turn: fenParts[1],
-			movesCount: fenParts[2],
-		};
-		let nextIdx = 3;
-		if (V.HasFlags)
-			Object.assign(res, {flags: fenParts[nextIdx++]});
-		if (V.HasEnpassant)
-			Object.assign(res, {enpassant: fenParts[nextIdx]});
-		return res;
-	}
-
-	// Return current fen (game state)
-	getFen()
-	{
-		return this.getBaseFen() + " " +
-			this.getTurnFen() + " " + this.movesCount +
-			(V.HasFlags ? (" " + this.getFlagsFen()) : "") +
-			(V.HasEnpassant ? (" " + this.getEnpassantFen()) : "");
-	}
-
-	// Position part of the FEN string
-	getBaseFen()
-	{
-		let position = "";
-		for (let i=0; i<V.size.x; i++)
-		{
-			let emptyCount = 0;
-			for (let j=0; j<V.size.y; j++)
-			{
-				if (this.board[i][j] == V.EMPTY)
-					emptyCount++;
-				else
-				{
-					if (emptyCount > 0)
-					{
-						// Add empty squares in-between
-						position += emptyCount;
-						emptyCount = 0;
-					}
-					position += V.board2fen(this.board[i][j]);
-				}
-			}
-			if (emptyCount > 0)
-			{
-				// "Flush remainder"
-				position += emptyCount;
-			}
-			if (i < V.size.x - 1)
-				position += "/"; //separate rows
-		}
-		return position;
-	}
-
-	getTurnFen()
-	{
-		return this.turn;
-	}
-
-	// Flags part of the FEN string
-	getFlagsFen()
-	{
-		let flags = "";
-		// Add castling flags
-		for (let i of ['w','b'])
-		{
-			for (let j=0; j<2; j++)
-				flags += (this.castleFlags[i][j] ? '1' : '0');
-		}
-		return flags;
-	}
-
-	// Enpassant part of the FEN string
-	getEnpassantFen()
-	{
-		const L = this.epSquares.length;
-		if (!this.epSquares[L-1])
-			return "-"; //no en-passant
-		return V.CoordsToSquare(this.epSquares[L-1]);
-	}
-
-	// Turn position fen into double array ["wb","wp","bk",...]
-	static GetBoard(position)
-	{
-		const rows = position.split("/");
-		let board = ArrayFun.init(V.size.x, V.size.y, "");
-		for (let i=0; i<rows.length; i++)
-		{
-			let j = 0;
-			for (let indexInRow = 0; indexInRow < rows[i].length; indexInRow++)
-			{
-				const character = rows[i][indexInRow];
-				const num = parseInt(character);
-				if (!isNaN(num))
-					j += num; //just shift j
-				else //something at position i,j
-					board[i][j++] = V.fen2board(character);
-			}
-		}
-		return board;
-	}
-
-	// Extract (relevant) flags from fen
-	setFlags(fenflags)
-	{
-		// white a-castle, h-castle, black a-castle, h-castle
-		this.castleFlags = {'w': [true,true], 'b': [true,true]};
-		if (!fenflags)
-			return;
-		for (let i=0; i<4; i++)
-			this.castleFlags[i < 2 ? 'w' : 'b'][i%2] = (fenflags.charAt(i) == '1');
-	}
-
-	//////////////////
-	// INITIALIZATION
-
-	// Fen string fully describes the game state
-	constructor(fen)
-	{
-		const fenParsed = V.ParseFen(fen);
-		this.board = V.GetBoard(fenParsed.position);
-		this.turn = fenParsed.turn[0]; //[0] to work with MarseilleRules
-		this.movesCount = parseInt(fenParsed.movesCount);
-		this.setOtherVariables(fen);
-	}
-
-	// Scan board for kings and rooks positions
-	scanKingsRooks(fen)
-	{
-		this.INIT_COL_KING = {'w':-1, 'b':-1};
-		this.INIT_COL_ROOK = {'w':[-1,-1], 'b':[-1,-1]};
-		this.kingPos = {'w':[-1,-1], 'b':[-1,-1]}; //squares of white and black king
-		const fenRows = V.ParseFen(fen).position.split("/");
-		for (let i=0; i<fenRows.length; i++)
-		{
-			let k = 0; //column index on board
-			for (let j=0; j<fenRows[i].length; j++)
-			{
-				switch (fenRows[i].charAt(j))
-				{
-					case 'k':
-						this.kingPos['b'] = [i,k];
-						this.INIT_COL_KING['b'] = k;
-						break;
-					case 'K':
-						this.kingPos['w'] = [i,k];
-						this.INIT_COL_KING['w'] = k;
-						break;
-					case 'r':
-						if (this.INIT_COL_ROOK['b'][0] < 0)
-							this.INIT_COL_ROOK['b'][0] = k;
-						else
-							this.INIT_COL_ROOK['b'][1] = k;
-						break;
-					case 'R':
-						if (this.INIT_COL_ROOK['w'][0] < 0)
-							this.INIT_COL_ROOK['w'][0] = k;
-						else
-							this.INIT_COL_ROOK['w'][1] = k;
-						break;
-					default:
-						const num = parseInt(fenRows[i].charAt(j));
-						if (!isNaN(num))
-							k += (num-1);
-				}
-				k++;
-			}
-		}
-	}
-
-	// Some additional variables from FEN (variant dependant)
-	setOtherVariables(fen)
-	{
-		// Set flags and enpassant:
-		const parsedFen = V.ParseFen(fen);
-		if (V.HasFlags)
-			this.setFlags(parsedFen.flags);
-		if (V.HasEnpassant)
-		{
-			const epSq = parsedFen.enpassant != "-"
-				? V.SquareToCoords(parsedFen.enpassant)
-				: undefined;
-			this.epSquares = [ epSq ];
-		}
-		// Search for king and rooks positions:
-		this.scanKingsRooks(fen);
-	}
-
-	/////////////////////
-	// GETTERS & SETTERS
-
-	static get size()
-	{
-		return {x:8, y:8};
-	}
-
-	// Color of thing on suqare (i,j). 'undefined' if square is empty
-	getColor(i,j)
-	{
-		return this.board[i][j].charAt(0);
-	}
-
-	// Piece type on square (i,j). 'undefined' if square is empty
-	getPiece(i,j)
-	{
-		return this.board[i][j].charAt(1);
-	}
-
-	// Get opponent color
-	static GetOppCol(color)
-	{
-		return (color=="w" ? "b" : "w");
-	}
-
-	// Get next color (for compatibility with 3 and 4 players games)
-	static GetNextCol(color)
-	{
-		return V.GetOppCol(color);
-	}
-
-	// Pieces codes (for a clearer code)
-	static get PAWN() { return 'p'; }
-	static get ROOK() { return 'r'; }
-	static get KNIGHT() { return 'n'; }
-	static get BISHOP() { return 'b'; }
-	static get QUEEN() { return 'q'; }
-	static get KING() { return 'k'; }
-
-	// For FEN checking:
-	static get PIECES()
-	{
-		return [V.PAWN,V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN,V.KING];
-	}
-
-	// Empty square
-	static get EMPTY() { return ""; }
-
-	// Some pieces movements
-	static get steps()
-	{
-		return {
-			'r': [ [-1,0],[1,0],[0,-1],[0,1] ],
-			'n': [ [-1,-2],[-1,2],[1,-2],[1,2],[-2,-1],[-2,1],[2,-1],[2,1] ],
-			'b': [ [-1,-1],[-1,1],[1,-1],[1,1] ],
-		};
-	}
-
-	////////////////////
-	// MOVES GENERATION
-
-	// All possible moves from selected square (assumption: color is OK)
-	getPotentialMovesFrom([x,y])
-	{
-		switch (this.getPiece(x,y))
-		{
-			case V.PAWN:
-				return this.getPotentialPawnMoves([x,y]);
-			case V.ROOK:
-				return this.getPotentialRookMoves([x,y]);
-			case V.KNIGHT:
-				return this.getPotentialKnightMoves([x,y]);
-			case V.BISHOP:
-				return this.getPotentialBishopMoves([x,y]);
-			case V.QUEEN:
-				return this.getPotentialQueenMoves([x,y]);
-			case V.KING:
-				return this.getPotentialKingMoves([x,y]);
-		}
-	}
-
-	// Build a regular move from its initial and destination squares.
-	// tr: transformation
-	getBasicMove([sx,sy], [ex,ey], tr)
-	{
-		let mv = new Move({
-			appear: [
-				new PiPo({
-					x: ex,
-					y: ey,
-					c: !!tr ? tr.c : this.getColor(sx,sy),
-					p: !!tr ? tr.p : this.getPiece(sx,sy)
-				})
-			],
-			vanish: [
-				new PiPo({
-					x: sx,
-					y: sy,
-					c: this.getColor(sx,sy),
-					p: this.getPiece(sx,sy)
-				})
-			]
-		});
-
-		// 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.getPiece(ex,ey)
-				})
-			);
-		}
-		return mv;
-	}
-
-	// Generic method to find possible moves of non-pawn pieces:
-	// "sliding or jumping"
-	getSlideNJumpMoves([x,y], steps, oneStep)
-	{
-		const color = this.getColor(x,y);
-		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 !== undefined)
-					continue outerLoop;
-				i += step[0];
-				j += step[1];
-			}
-			if (V.OnBoard(i,j) && this.canTake([x,y], [i,j]))
-				moves.push(this.getBasicMove([x,y], [i,j]));
-		}
-		return moves;
-	}
-
-	// What are the pawn moves from square x,y ?
-	getPotentialPawnMoves([x,y])
-	{
-		const color = this.turn;
-		let moves = [];
-		const [sizeX,sizeY] = [V.size.x,V.size.y];
-		const shiftX = (color == "w" ? -1 : 1);
-		const firstRank = (color == 'w' ? sizeX-1 : 0);
-		const startRank = (color == "w" ? sizeX-2 : 1);
-		const lastRank = (color == "w" ? 0 : sizeX-1);
-		const pawnColor = this.getColor(x,y); //can be different for checkered
-
-		// NOTE: next condition is generally true (no pawn on last rank)
-		if (x+shiftX >= 0 && x+shiftX < sizeX)
-		{
-			const finalPieces = x + shiftX == lastRank
-				? [V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN]
-				: [V.PAWN]
-			// One square forward
-			if (this.board[x+shiftX][y] == V.EMPTY)
-			{
-				for (let piece of finalPieces)
-				{
-					moves.push(this.getBasicMove([x,y], [x+shiftX,y],
-						{c:pawnColor,p:piece}));
-				}
-				// Next condition because pawns on 1st rank can generally jump
-				if ([startRank,firstRank].includes(x)
-					&& 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])
-			{
-				if (y + shiftY >= 0 && y + shiftY < sizeY
-					&& this.board[x+shiftX][y+shiftY] != V.EMPTY
-					&& this.canTake([x,y], [x+shiftX,y+shiftY]))
-				{
-					for (let piece of finalPieces)
-					{
-						moves.push(this.getBasicMove([x,y], [x+shiftX,y+shiftY],
-							{c:pawnColor,p:piece}));
-					}
-				}
-			}
-		}
-
-		if (V.HasEnpassant)
-		{
-			// En passant
-			const Lep = this.epSquares.length;
-			const epSquare = this.epSquares[Lep-1]; //always at least one element
-			if (!!epSquare && epSquare.x == x+shiftX && Math.abs(epSquare.y - y) == 1)
-			{
-				let enpassantMove = this.getBasicMove([x,y], [epSquare.x,epSquare.y]);
-				enpassantMove.vanish.push({
-					x: x,
-					y: epSquare.y,
-					p: 'p',
-					c: this.getColor(x,epSquare.y)
-				});
-				moves.push(enpassantMove);
-			}
-		}
-
-		return moves;
-	}
-
-	// What are the rook moves from square x,y ?
-	getPotentialRookMoves(sq)
-	{
-		return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]);
-	}
-
-	// What are the knight moves from square x,y ?
-	getPotentialKnightMoves(sq)
-	{
-		return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep");
-	}
-
-	// What are the bishop moves from square x,y ?
-	getPotentialBishopMoves(sq)
-	{
-		return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]);
-	}
-
-	// What are the queen moves from square x,y ?
-	getPotentialQueenMoves(sq)
-	{
-		return this.getSlideNJumpMoves(sq,
-			V.steps[V.ROOK].concat(V.steps[V.BISHOP]));
-	}
-
-	// What are the king moves from square x,y ?
-	getPotentialKingMoves(sq)
-	{
-		// Initialize with normal moves
-		let moves = this.getSlideNJumpMoves(sq,
-			V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
-		return moves.concat(this.getCastleMoves(sq));
-	}
-
-	getCastleMoves([x,y])
-	{
-		const c = this.getColor(x,y);
-		if (x != (c=="w" ? V.size.x-1 : 0) || y != this.INIT_COL_KING[c])
-			return []; //x isn't first rank, or king has moved (shortcut)
-
-		// Castling ?
-		const oppCol = V.GetOppCol(c);
-		let moves = [];
-		let i = 0;
-		const finalSquares = [ [2,3], [V.size.y-2,V.size.y-3] ]; //king, then rook
-		castlingCheck:
-		for (let castleSide=0; castleSide < 2; castleSide++) //large, then small
-		{
-			if (!this.castleFlags[c][castleSide])
-				continue;
-			// If this code is reached, rooks and king are on initial position
-
-			// Nothing on the path of the king ?
-			// (And no checks; OK also if y==finalSquare)
-			let step = finalSquares[castleSide][0] < y ? -1 : 1;
-			for (i=y; i!=finalSquares[castleSide][0]; i+=step)
-			{
-				if (this.isAttacked([x,i], [oppCol]) || (this.board[x][i] != V.EMPTY &&
-					// NOTE: next check is enough, because of chessboard constraints
-					(this.getColor(x,i) != c
-						|| ![V.KING,V.ROOK].includes(this.getPiece(x,i)))))
-				{
-					continue castlingCheck;
-				}
-			}
-
-			// Nothing on the path to the rook?
-			step = castleSide == 0 ? -1 : 1;
-			for (i = y + step; i != this.INIT_COL_ROOK[c][castleSide]; i += step)
-			{
-				if (this.board[x][i] != V.EMPTY)
-					continue castlingCheck;
-			}
-			const rookPos = this.INIT_COL_ROOK[c][castleSide];
-
-			// Nothing on final squares, except maybe king and castling rook?
-			for (i=0; i<2; i++)
-			{
-				if (this.board[x][finalSquares[castleSide][i]] != V.EMPTY &&
-					this.getPiece(x,finalSquares[castleSide][i]) != V.KING &&
-					finalSquares[castleSide][i] != rookPos)
-				{
-					continue castlingCheck;
-				}
-			}
-
-			// If this code is reached, castle is valid
-			moves.push( new Move({
-				appear: [
-					new PiPo({x:x,y:finalSquares[castleSide][0],p:V.KING,c:c}),
-					new PiPo({x:x,y:finalSquares[castleSide][1],p:V.ROOK,c:c})],
-				vanish: [
-					new PiPo({x:x,y:y,p:V.KING,c:c}),
-					new PiPo({x:x,y:rookPos,p:V.ROOK,c:c})],
-				end: Math.abs(y - rookPos) <= 2
-					? {x:x, y:rookPos}
-					: {x:x, y:y + 2 * (castleSide==0 ? -1 : 1)}
-			}) );
-		}
-
-		return moves;
-	}
-
-	////////////////////
-	// MOVES VALIDATION
-
-	// For the interface: possible moves for the current turn from square sq
-	getPossibleMovesFrom(sq)
-	{
-		return this.filterValid( this.getPotentialMovesFrom(sq) );
-	}
-
-	// TODO: promotions (into R,B,N,Q) should be filtered only once
-	filterValid(moves)
-	{
-		if (moves.length == 0)
-			return [];
-		const color = this.turn;
-		return moves.filter(m => {
-			this.play(m);
-			const res = !this.underCheck(color);
-			this.undo(m);
-			return res;
-		});
-	}
-
-	// Search for all valid moves considering current turn
-	// (for engine and game end)
-	getAllValidMoves()
-	{
-		const color = this.turn;
-		const oppCol = V.GetOppCol(color);
-		let potentialMoves = [];
-		for (let i=0; i<V.size.x; i++)
-		{
-			for (let j=0; j<V.size.y; j++)
-			{
-				// Next condition "!= oppCol" to work with checkered variant
-				if (this.board[i][j] != V.EMPTY && this.getColor(i,j) != oppCol)
-				{
-					Array.prototype.push.apply(potentialMoves,
-						this.getPotentialMovesFrom([i,j]));
-				}
-			}
-		}
-		return this.filterValid(potentialMoves);
-	}
-
-	// Stop at the first move found
-	atLeastOneMove()
-	{
-		const color = this.turn;
-		const oppCol = V.GetOppCol(color);
-		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 && this.getColor(i,j) != oppCol)
-				{
-					const moves = this.getPotentialMovesFrom([i,j]);
-					if (moves.length > 0)
-					{
-						for (let k=0; k<moves.length; k++)
-						{
-							if (this.filterValid([moves[k]]).length > 0)
-								return true;
-						}
-					}
-				}
-			}
-		}
-		return false;
-	}
-
-	// Check if pieces of color in 'colors' are attacking (king) on square x,y
-	isAttacked(sq, colors)
-	{
-		return (this.isAttackedByPawn(sq, colors)
-			|| this.isAttackedByRook(sq, colors)
-			|| this.isAttackedByKnight(sq, colors)
-			|| this.isAttackedByBishop(sq, colors)
-			|| this.isAttackedByQueen(sq, colors)
-			|| this.isAttackedByKing(sq, colors));
-	}
-
-	// Is square x,y attacked by 'colors' pawns ?
-	isAttackedByPawn([x,y], colors)
-	{
-		for (let c of colors)
-		{
-			let pawnShift = (c=="w" ? 1 : -1);
-			if (x+pawnShift>=0 && x+pawnShift<V.size.x)
-			{
-				for (let i of [-1,1])
-				{
-					if (y+i>=0 && y+i<V.size.y && this.getPiece(x+pawnShift,y+i)==V.PAWN
-						&& this.getColor(x+pawnShift,y+i)==c)
-					{
-						return true;
-					}
-				}
-			}
-		}
-		return false;
-	}
-
-	// Is square x,y attacked by 'colors' rooks ?
-	isAttackedByRook(sq, colors)
-	{
-		return this.isAttackedBySlideNJump(sq, colors, V.ROOK, V.steps[V.ROOK]);
-	}
-
-	// Is square x,y attacked by 'colors' knights ?
-	isAttackedByKnight(sq, colors)
-	{
-		return this.isAttackedBySlideNJump(sq, colors,
-			V.KNIGHT, V.steps[V.KNIGHT], "oneStep");
-	}
-
-	// Is square x,y attacked by 'colors' bishops ?
-	isAttackedByBishop(sq, colors)
-	{
-		return this.isAttackedBySlideNJump(sq, colors, V.BISHOP, V.steps[V.BISHOP]);
-	}
-
-	// Is square x,y attacked by 'colors' queens ?
-	isAttackedByQueen(sq, colors)
-	{
-		return this.isAttackedBySlideNJump(sq, colors, V.QUEEN,
-			V.steps[V.ROOK].concat(V.steps[V.BISHOP]));
-	}
-
-	// Is square x,y attacked by 'colors' king(s) ?
-	isAttackedByKing(sq, colors)
-	{
-		return this.isAttackedBySlideNJump(sq, colors, V.KING,
-			V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
-	}
-
-	// Generic method for non-pawn pieces ("sliding or jumping"):
-	// is x,y attacked by a piece of color in array 'colors' ?
-	isAttackedBySlideNJump([x,y], colors, piece, steps, oneStep)
-	{
-		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 && !oneStep)
-			{
-				rx += step[0];
-				ry += step[1];
-			}
-			if (V.OnBoard(rx,ry) && this.getPiece(rx,ry) === piece
-				&& colors.includes(this.getColor(rx,ry)))
-			{
-				return true;
-			}
-		}
-		return false;
-	}
-
-	// Is color under check after his move ?
-	underCheck(color)
-	{
-		return this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]);
-	}
-
-	/////////////////
-	// MOVES PLAYING
-
-	// Apply a move on board
-	static PlayOnBoard(board, move)
-	{
-		for (let psq of move.vanish)
-			board[psq.x][psq.y] = V.EMPTY;
-		for (let psq of move.appear)
-			board[psq.x][psq.y] = psq.c + psq.p;
-	}
-	// Un-apply the played move
-	static UndoOnBoard(board, move)
-	{
-		for (let psq of move.appear)
-			board[psq.x][psq.y] = V.EMPTY;
-		for (let psq of move.vanish)
-			board[psq.x][psq.y] = psq.c + psq.p;
-	}
-
-	// After move is played, update variables + flags
-	updateVariables(move)
-	{
-		let piece = undefined;
-		let c = undefined;
-		if (move.vanish.length >= 1)
-		{
-			// Usual case, something is moved
-			piece = move.vanish[0].p;
-			c = move.vanish[0].c;
-		}
-		else
-		{
-			// Crazyhouse-like variants
-			piece = move.appear[0].p;
-			c = move.appear[0].c;
-		}
-		if (c == "c") //if (!["w","b"].includes(c))
-		{
-			// 'c = move.vanish[0].c' doesn't work for Checkered
-			c = V.GetOppCol(this.turn);
-		}
-		const firstRank = (c == "w" ? V.size.x-1 : 0);
-
-		// Update king position + flags
-		if (piece == V.KING && move.appear.length > 0)
-		{
-			this.kingPos[c][0] = move.appear[0].x;
-			this.kingPos[c][1] = move.appear[0].y;
-			if (V.HasFlags)
-				this.castleFlags[c] = [false,false];
-			return;
-		}
-		if (V.HasFlags)
-		{
-			// Update castling flags if rooks are moved
-			const oppCol = V.GetOppCol(c);
-			const oppFirstRank = (V.size.x-1) - firstRank;
-			if (move.start.x == firstRank //our rook moves?
-				&& this.INIT_COL_ROOK[c].includes(move.start.y))
-			{
-				const flagIdx = (move.start.y == this.INIT_COL_ROOK[c][0] ? 0 : 1);
-				this.castleFlags[c][flagIdx] = false;
-			}
-			else if (move.end.x == oppFirstRank //we took opponent rook?
-				&& this.INIT_COL_ROOK[oppCol].includes(move.end.y))
-			{
-				const flagIdx = (move.end.y == this.INIT_COL_ROOK[oppCol][0] ? 0 : 1);
-				this.castleFlags[oppCol][flagIdx] = false;
-			}
-		}
-	}
-
-	// After move is undo-ed *and flags resetted*, un-update other variables
-	// TODO: more symmetry, by storing flags increment in move (?!)
-	unupdateVariables(move)
-	{
-		// (Potentially) Reset king position
-		const c = this.getColor(move.start.x,move.start.y);
-		if (this.getPiece(move.start.x,move.start.y) == V.KING)
-			this.kingPos[c] = [move.start.x, move.start.y];
-	}
-
-	play(move)
-	{
-		// DEBUG:
-//		if (!this.states) this.states = [];
-//		const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
-//		this.states.push(stateFen);
-
-		if (V.HasFlags)
-			move.flags = JSON.stringify(this.aggregateFlags()); //save flags (for undo)
-		if (V.HasEnpassant)
-			this.epSquares.push( this.getEpSquare(move) );
-		if (!move.color)
-			move.color = this.turn; //for interface
-		V.PlayOnBoard(this.board, move);
-		this.turn = V.GetOppCol(this.turn);
-		this.movesCount++;
-		this.updateVariables(move);
-	}
-
-	undo(move)
-	{
-		if (V.HasEnpassant)
-			this.epSquares.pop();
-		if (V.HasFlags)
-			this.disaggregateFlags(JSON.parse(move.flags));
-		V.UndoOnBoard(this.board, move);
-		this.turn = V.GetOppCol(this.turn);
-		this.movesCount--;
-		this.unupdateVariables(move);
-
-		// DEBUG:
-//		const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
-//		if (stateFen != this.states[this.states.length-1]) debugger;
-//		this.states.pop();
-	}
-
-	///////////////
-	// END OF GAME
-
-	// What is the score ? (Interesting if game is over)
-	getCurrentScore()
-	{
-		if (this.atLeastOneMove()) // game not over
-			return "*";
-
-		// Game over
-		const color = this.turn;
-		// No valid move: stalemate or checkmate?
-		if (!this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]))
-			return "1/2";
-		// OK, checkmate
-		return (color == "w" ? "0-1" : "1-0");
-	}
-
-	///////////////
-	// ENGINE PLAY
-
-	// Pieces values
-	static get VALUES()
-	{
-		return {
-			'p': 1,
-			'r': 5,
-			'n': 3,
-			'b': 3,
-			'q': 9,
-			'k': 1000
-		};
-	}
-
-	// "Checkmate" (unreachable eval)
-	static get INFINITY() { return 9999; }
-
-	// At this value or above, the game is over
-	static get THRESHOLD_MATE() { return V.INFINITY; }
-
-	// Search depth: 2 for high branching factor, 4 for small (Loser chess, eg.)
-	static get SEARCH_DEPTH() { return 3; }
-
-	// Assumption: at least one legal move
-	// NOTE: works also for extinction chess because depth is 3...
-	getComputerMove()
-	{
-		const maxeval = V.INFINITY;
-		const color = this.turn;
-		// Some variants may show a bigger moves list to the human (Switching),
-		// thus the argument "computer" below (which is generally ignored)
-		let moves1 = this.getAllValidMoves("computer");
-
-		// Can I mate in 1 ? (for Magnetic & Extinction)
-		for (let i of shuffle(ArrayFun.range(moves1.length)))
-		{
-			this.play(moves1[i]);
-			let finish = (Math.abs(this.evalPosition()) >= V.THRESHOLD_MATE);
-			if (!finish)
-			{
-				const score = this.getCurrentScore();
-				if (["1-0","0-1"].includes(score))
-					finish = true;
-			}
-			this.undo(moves1[i]);
-			if (finish)
-				return moves1[i];
-		}
-
-		// Rank moves using a min-max at depth 2
-		for (let i=0; i<moves1.length; i++)
-		{
-			// Initial self evaluation is very low: "I'm checkmated"
-			moves1[i].eval = (color=="w" ? -1 : 1) * maxeval;
-			this.play(moves1[i]);
-			const score1 = this.getCurrentScore();
-			let eval2 = undefined;
-			if (score1 == "*")
-			{
-				// Initial enemy evaluation is very low too, for him
-				eval2 = (color=="w" ? 1 : -1) * maxeval;
-				// Second half-move:
-				let moves2 = this.getAllValidMoves("computer");
-				for (let j=0; j<moves2.length; j++)
-				{
-					this.play(moves2[j]);
-					const score2 = this.getCurrentScore();
-					const evalPos = score2 == "*"
-						? this.evalPosition()
-						: (score2=="1/2" ? 0 : (score2=="1-0" ? 1 : -1) * maxeval);
-					if ((color == "w" && evalPos < eval2)
-						|| (color=="b" && evalPos > eval2))
-					{
-						eval2 = evalPos;
-					}
-					this.undo(moves2[j]);
-				}
-			}
-			else
-				eval2 = (score1=="1/2" ? 0 : (score1=="1-0" ? 1 : -1) * maxeval);
-			if ((color=="w" && eval2 > moves1[i].eval)
-				|| (color=="b" && eval2 < moves1[i].eval))
-			{
-				moves1[i].eval = eval2;
-			}
-			this.undo(moves1[i]);
-		}
-		moves1.sort( (a,b) => { return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
-
-		let candidates = [0]; //indices of candidates moves
-		for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
-			candidates.push(j);
-		let currentBest = moves1[sample(candidates)];
-
-		// From here, depth >= 3: may take a while, so we control time
-		const timeStart = Date.now();
-
-		// Skip depth 3+ if we found a checkmate (or if we are checkmated in 1...)
-		if (V.SEARCH_DEPTH >= 3 && Math.abs(moves1[0].eval) < V.THRESHOLD_MATE)
-		{
-			for (let i=0; i<moves1.length; i++)
-			{
-				if (Date.now()-timeStart >= 5000) //more than 5 seconds
-					return currentBest; //depth 2 at least
-				this.play(moves1[i]);
-				// 0.1 * oldEval : heuristic to avoid some bad moves (not all...)
-				moves1[i].eval = 0.1*moves1[i].eval +
-					this.alphabeta(V.SEARCH_DEPTH-1, -maxeval, maxeval);
-				this.undo(moves1[i]);
-			}
-			moves1.sort( (a,b) => {
-				return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
-		}
-		else
-			return currentBest;
-//		console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
-
-		candidates = [0];
-		for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
-			candidates.push(j);
-		return moves1[sample(candidates)];
-	}
-
-	alphabeta(depth, alpha, beta)
-  {
-		const maxeval = V.INFINITY;
-		const color = this.turn;
-		const score = this.getCurrentScore();
-		if (score != "*")
-			return (score=="1/2" ? 0 : (score=="1-0" ? 1 : -1) * maxeval);
-		if (depth == 0)
+  //////////////
+  // MISC UTILS
+
+  static get HasFlags() { return true; } //some variants don't have flags
+
+  static get HasEnpassant() { return true; } //some variants don't have ep.
+
+  // Path to pieces
+  static getPpath(b)
+  {
+    return b; //usual pieces in pieces/ folder
+  }
+
+  // Turn "wb" into "B" (for FEN)
+  static board2fen(b)
+  {
+    return b[0]=='w' ? b[1].toUpperCase() : b[1];
+  }
+
+  // Turn "p" into "bp" (for board)
+  static fen2board(f)
+  {
+    return f.charCodeAt()<=90 ? "w"+f.toLowerCase() : "b"+f;
+  }
+
+  // Check if FEN describe a position
+  static IsGoodFen(fen)
+  {
+    const fenParsed = V.ParseFen(fen);
+    // 1) Check position
+    if (!V.IsGoodPosition(fenParsed.position))
+      return false;
+    // 2) Check turn
+    if (!fenParsed.turn || !V.IsGoodTurn(fenParsed.turn))
+      return false;
+    // 3) Check moves count
+    if (!fenParsed.movesCount || !(parseInt(fenParsed.movesCount) >= 0))
+      return false;
+    // 4) Check flags
+    if (V.HasFlags && (!fenParsed.flags || !V.IsGoodFlags(fenParsed.flags)))
+      return false;
+    // 5) Check enpassant
+    if (V.HasEnpassant &&
+      (!fenParsed.enpassant || !V.IsGoodEnpassant(fenParsed.enpassant)))
+    {
+      return false;
+    }
+    return true;
+  }
+
+  // Is position part of the FEN a priori correct?
+  static IsGoodPosition(position)
+  {
+    if (position.length == 0)
+      return false;
+    const rows = position.split("/");
+    if (rows.length != V.size.x)
+      return false;
+    for (let row of rows)
+    {
+      let sumElts = 0;
+      for (let i=0; i<row.length; i++)
+      {
+        if (V.PIECES.includes(row[i].toLowerCase()))
+          sumElts++;
+        else
+        {
+          const num = parseInt(row[i]);
+          if (isNaN(num))
+            return false;
+          sumElts += num;
+        }
+      }
+      if (sumElts != V.size.y)
+        return false;
+    }
+    return true;
+  }
+
+  // For FEN checking
+  static IsGoodTurn(turn)
+  {
+    return ["w","b"].includes(turn);
+  }
+
+  // For FEN checking
+  static IsGoodFlags(flags)
+  {
+    return !!flags.match(/^[01]{4,4}$/);
+  }
+
+  static IsGoodEnpassant(enpassant)
+  {
+    if (enpassant != "-")
+    {
+      const ep = V.SquareToCoords(fenParsed.enpassant);
+      if (isNaN(ep.x) || !V.OnBoard(ep))
+        return false;
+    }
+    return true;
+  }
+
+  // 3 --> d (column number to letter)
+  static CoordToColumn(colnum)
+  {
+    return String.fromCharCode(97 + colnum);
+  }
+
+  // d --> 3 (column letter to number)
+  static ColumnToCoord(column)
+  {
+    return column.charCodeAt(0) - 97;
+  }
+
+  // a4 --> {x:3,y:0}
+  static SquareToCoords(sq)
+  {
+    return {
+      // NOTE: column is always one char => max 26 columns
+      // row is counted from black side => subtraction
+      x: V.size.x - parseInt(sq.substr(1)),
+      y: sq[0].charCodeAt() - 97
+    };
+  }
+
+  // {x:0,y:4} --> e8
+  static CoordsToSquare(coords)
+  {
+    return V.CoordToColumn(coords.y) + (V.size.x - coords.x);
+  }
+
+  // Aggregates flags into one object
+  aggregateFlags()
+  {
+    return this.castleFlags;
+  }
+
+  // Reverse operation
+  disaggregateFlags(flags)
+  {
+    this.castleFlags = flags;
+  }
+
+  // En-passant square, if any
+  getEpSquare(moveOrSquare)
+  {
+    if (!moveOrSquare)
+      return undefined;
+    if (typeof moveOrSquare === "string")
+    {
+      const square = moveOrSquare;
+      if (square == "-")
+        return undefined;
+      return V.SquareToCoords(square);
+    }
+    // Argument is a move:
+    const move = moveOrSquare;
+    const [sx,sy,ex] = [move.start.x,move.start.y,move.end.x];
+    // TODO: next conditions are first for Atomic, and last for Checkered
+    if (move.appear.length > 0 && Math.abs(sx - ex) == 2
+      && move.appear[0].p == V.PAWN && ["w","b"].includes(move.appear[0].c))
+    {
+      return {
+        x: (sx + ex)/2,
+        y: sy
+      };
+    }
+    return undefined; //default
+  }
+
+  // Can thing on square1 take thing on square2
+  canTake([x1,y1], [x2,y2])
+  {
+    return this.getColor(x1,y1) !== this.getColor(x2,y2);
+  }
+
+  // Is (x,y) on the chessboard?
+  static OnBoard(x,y)
+  {
+    return (x>=0 && x<V.size.x && y>=0 && y<V.size.y);
+  }
+
+  // Used in interface: 'side' arg == player color
+  canIplay(side, [x,y])
+  {
+    return (this.turn == side && this.getColor(x,y) == side);
+  }
+
+  // On which squares is color under check ? (for interface)
+  getCheckSquares(color)
+  {
+    return this.isAttacked(this.kingPos[color], [V.GetOppCol(color)])
+      ? [JSON.parse(JSON.stringify(this.kingPos[color]))] //need to duplicate!
+      : [];
+  }
+
+  /////////////
+  // FEN UTILS
+
+  // Setup the initial random (assymetric) position
+  static GenRandInitFen()
+  {
+    let pieces = { "w": new Array(8), "b": new Array(8) };
+    // Shuffle pieces on first and last rank
+    for (let c of ["w","b"])
+    {
+      let positions = ArrayFun.range(8);
+
+      // Get random squares for bishops
+      let randIndex = 2 * random(4);
+      const bishop1Pos = positions[randIndex];
+      // The second bishop must be on a square of different color
+      let randIndex_tmp = 2 * random(4) + 1;
+      const 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 = random(6);
+      const knight1Pos = positions[randIndex];
+      positions.splice(randIndex, 1);
+      randIndex = random(5);
+      const knight2Pos = positions[randIndex];
+      positions.splice(randIndex, 1);
+
+      // Get random square for queen
+      randIndex = random(4);
+      const queenPos = positions[randIndex];
+      positions.splice(randIndex, 1);
+
+      // Rooks and king positions are now fixed,
+      // because of the ordering rook-king-rook
+      const rook1Pos = positions[0];
+      const kingPos = positions[1];
+      const rook2Pos = positions[2];
+
+      // 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';
+      pieces[c][kingPos] = 'k';
+      pieces[c][bishop2Pos] = 'b';
+      pieces[c][knight2Pos] = 'n';
+      pieces[c][rook2Pos] = 'r';
+    }
+    return pieces["b"].join("") +
+      "/pppppppp/8/8/8/8/PPPPPPPP/" +
+      pieces["w"].join("").toUpperCase() +
+      " w 0 1111 -"; //add turn + flags + enpassant
+  }
+
+  // "Parse" FEN: just return untransformed string data
+  static ParseFen(fen)
+  {
+    const fenParts = fen.split(" ");
+    let res =
+    {
+      position: fenParts[0],
+      turn: fenParts[1],
+      movesCount: fenParts[2],
+    };
+    let nextIdx = 3;
+    if (V.HasFlags)
+      Object.assign(res, {flags: fenParts[nextIdx++]});
+    if (V.HasEnpassant)
+      Object.assign(res, {enpassant: fenParts[nextIdx]});
+    return res;
+  }
+
+  // Return current fen (game state)
+  getFen()
+  {
+    return this.getBaseFen() + " " +
+      this.getTurnFen() + " " + this.movesCount +
+      (V.HasFlags ? (" " + this.getFlagsFen()) : "") +
+      (V.HasEnpassant ? (" " + this.getEnpassantFen()) : "");
+  }
+
+  // Position part of the FEN string
+  getBaseFen()
+  {
+    let position = "";
+    for (let i=0; i<V.size.x; i++)
+    {
+      let emptyCount = 0;
+      for (let j=0; j<V.size.y; j++)
+      {
+        if (this.board[i][j] == V.EMPTY)
+          emptyCount++;
+        else
+        {
+          if (emptyCount > 0)
+          {
+            // Add empty squares in-between
+            position += emptyCount;
+            emptyCount = 0;
+          }
+          position += V.board2fen(this.board[i][j]);
+        }
+      }
+      if (emptyCount > 0)
+      {
+        // "Flush remainder"
+        position += emptyCount;
+      }
+      if (i < V.size.x - 1)
+        position += "/"; //separate rows
+    }
+    return position;
+  }
+
+  getTurnFen()
+  {
+    return this.turn;
+  }
+
+  // Flags part of the FEN string
+  getFlagsFen()
+  {
+    let flags = "";
+    // Add castling flags
+    for (let i of ['w','b'])
+    {
+      for (let j=0; j<2; j++)
+        flags += (this.castleFlags[i][j] ? '1' : '0');
+    }
+    return flags;
+  }
+
+  // Enpassant part of the FEN string
+  getEnpassantFen()
+  {
+    const L = this.epSquares.length;
+    if (!this.epSquares[L-1])
+      return "-"; //no en-passant
+    return V.CoordsToSquare(this.epSquares[L-1]);
+  }
+
+  // Turn position fen into double array ["wb","wp","bk",...]
+  static GetBoard(position)
+  {
+    const rows = position.split("/");
+    let board = ArrayFun.init(V.size.x, V.size.y, "");
+    for (let i=0; i<rows.length; i++)
+    {
+      let j = 0;
+      for (let indexInRow = 0; indexInRow < rows[i].length; indexInRow++)
+      {
+        const character = rows[i][indexInRow];
+        const num = parseInt(character);
+        if (!isNaN(num))
+          j += num; //just shift j
+        else //something at position i,j
+          board[i][j++] = V.fen2board(character);
+      }
+    }
+    return board;
+  }
+
+  // Extract (relevant) flags from fen
+  setFlags(fenflags)
+  {
+    // white a-castle, h-castle, black a-castle, h-castle
+    this.castleFlags = {'w': [true,true], 'b': [true,true]};
+    if (!fenflags)
+      return;
+    for (let i=0; i<4; i++)
+      this.castleFlags[i < 2 ? 'w' : 'b'][i%2] = (fenflags.charAt(i) == '1');
+  }
+
+  //////////////////
+  // INITIALIZATION
+
+  // Fen string fully describes the game state
+  constructor(fen)
+  {
+    const fenParsed = V.ParseFen(fen);
+    this.board = V.GetBoard(fenParsed.position);
+    this.turn = fenParsed.turn[0]; //[0] to work with MarseilleRules
+    this.movesCount = parseInt(fenParsed.movesCount);
+    this.setOtherVariables(fen);
+  }
+
+  // Scan board for kings and rooks positions
+  scanKingsRooks(fen)
+  {
+    this.INIT_COL_KING = {'w':-1, 'b':-1};
+    this.INIT_COL_ROOK = {'w':[-1,-1], 'b':[-1,-1]};
+    this.kingPos = {'w':[-1,-1], 'b':[-1,-1]}; //squares of white and black king
+    const fenRows = V.ParseFen(fen).position.split("/");
+    for (let i=0; i<fenRows.length; i++)
+    {
+      let k = 0; //column index on board
+      for (let j=0; j<fenRows[i].length; j++)
+      {
+        switch (fenRows[i].charAt(j))
+        {
+          case 'k':
+            this.kingPos['b'] = [i,k];
+            this.INIT_COL_KING['b'] = k;
+            break;
+          case 'K':
+            this.kingPos['w'] = [i,k];
+            this.INIT_COL_KING['w'] = k;
+            break;
+          case 'r':
+            if (this.INIT_COL_ROOK['b'][0] < 0)
+              this.INIT_COL_ROOK['b'][0] = k;
+            else
+              this.INIT_COL_ROOK['b'][1] = k;
+            break;
+          case 'R':
+            if (this.INIT_COL_ROOK['w'][0] < 0)
+              this.INIT_COL_ROOK['w'][0] = k;
+            else
+              this.INIT_COL_ROOK['w'][1] = k;
+            break;
+          default:
+            const num = parseInt(fenRows[i].charAt(j));
+            if (!isNaN(num))
+              k += (num-1);
+        }
+        k++;
+      }
+    }
+  }
+
+  // Some additional variables from FEN (variant dependant)
+  setOtherVariables(fen)
+  {
+    // Set flags and enpassant:
+    const parsedFen = V.ParseFen(fen);
+    if (V.HasFlags)
+      this.setFlags(parsedFen.flags);
+    if (V.HasEnpassant)
+    {
+      const epSq = parsedFen.enpassant != "-"
+        ? V.SquareToCoords(parsedFen.enpassant)
+        : undefined;
+      this.epSquares = [ epSq ];
+    }
+    // Search for king and rooks positions:
+    this.scanKingsRooks(fen);
+  }
+
+  /////////////////////
+  // GETTERS & SETTERS
+
+  static get size()
+  {
+    return {x:8, y:8};
+  }
+
+  // Color of thing on suqare (i,j). 'undefined' if square is empty
+  getColor(i,j)
+  {
+    return this.board[i][j].charAt(0);
+  }
+
+  // Piece type on square (i,j). 'undefined' if square is empty
+  getPiece(i,j)
+  {
+    return this.board[i][j].charAt(1);
+  }
+
+  // Get opponent color
+  static GetOppCol(color)
+  {
+    return (color=="w" ? "b" : "w");
+  }
+
+  // Get next color (for compatibility with 3 and 4 players games)
+  static GetNextCol(color)
+  {
+    return V.GetOppCol(color);
+  }
+
+  // Pieces codes (for a clearer code)
+  static get PAWN() { return 'p'; }
+  static get ROOK() { return 'r'; }
+  static get KNIGHT() { return 'n'; }
+  static get BISHOP() { return 'b'; }
+  static get QUEEN() { return 'q'; }
+  static get KING() { return 'k'; }
+
+  // For FEN checking:
+  static get PIECES()
+  {
+    return [V.PAWN,V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN,V.KING];
+  }
+
+  // Empty square
+  static get EMPTY() { return ""; }
+
+  // Some pieces movements
+  static get steps()
+  {
+    return {
+      'r': [ [-1,0],[1,0],[0,-1],[0,1] ],
+      'n': [ [-1,-2],[-1,2],[1,-2],[1,2],[-2,-1],[-2,1],[2,-1],[2,1] ],
+      'b': [ [-1,-1],[-1,1],[1,-1],[1,1] ],
+    };
+  }
+
+  ////////////////////
+  // MOVES GENERATION
+
+  // All possible moves from selected square (assumption: color is OK)
+  getPotentialMovesFrom([x,y])
+  {
+    switch (this.getPiece(x,y))
+    {
+      case V.PAWN:
+        return this.getPotentialPawnMoves([x,y]);
+      case V.ROOK:
+        return this.getPotentialRookMoves([x,y]);
+      case V.KNIGHT:
+        return this.getPotentialKnightMoves([x,y]);
+      case V.BISHOP:
+        return this.getPotentialBishopMoves([x,y]);
+      case V.QUEEN:
+        return this.getPotentialQueenMoves([x,y]);
+      case V.KING:
+        return this.getPotentialKingMoves([x,y]);
+    }
+  }
+
+  // Build a regular move from its initial and destination squares.
+  // tr: transformation
+  getBasicMove([sx,sy], [ex,ey], tr)
+  {
+    let mv = new Move({
+      appear: [
+        new PiPo({
+          x: ex,
+          y: ey,
+          c: !!tr ? tr.c : this.getColor(sx,sy),
+          p: !!tr ? tr.p : this.getPiece(sx,sy)
+        })
+      ],
+      vanish: [
+        new PiPo({
+          x: sx,
+          y: sy,
+          c: this.getColor(sx,sy),
+          p: this.getPiece(sx,sy)
+        })
+      ]
+    });
+
+    // 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.getPiece(ex,ey)
+        })
+      );
+    }
+    return mv;
+  }
+
+  // Generic method to find possible moves of non-pawn pieces:
+  // "sliding or jumping"
+  getSlideNJumpMoves([x,y], steps, oneStep)
+  {
+    const color = this.getColor(x,y);
+    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 !== undefined)
+          continue outerLoop;
+        i += step[0];
+        j += step[1];
+      }
+      if (V.OnBoard(i,j) && this.canTake([x,y], [i,j]))
+        moves.push(this.getBasicMove([x,y], [i,j]));
+    }
+    return moves;
+  }
+
+  // What are the pawn moves from square x,y ?
+  getPotentialPawnMoves([x,y])
+  {
+    const color = this.turn;
+    let moves = [];
+    const [sizeX,sizeY] = [V.size.x,V.size.y];
+    const shiftX = (color == "w" ? -1 : 1);
+    const firstRank = (color == 'w' ? sizeX-1 : 0);
+    const startRank = (color == "w" ? sizeX-2 : 1);
+    const lastRank = (color == "w" ? 0 : sizeX-1);
+    const pawnColor = this.getColor(x,y); //can be different for checkered
+
+    // NOTE: next condition is generally true (no pawn on last rank)
+    if (x+shiftX >= 0 && x+shiftX < sizeX)
+    {
+      const finalPieces = x + shiftX == lastRank
+        ? [V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN]
+        : [V.PAWN]
+      // One square forward
+      if (this.board[x+shiftX][y] == V.EMPTY)
+      {
+        for (let piece of finalPieces)
+        {
+          moves.push(this.getBasicMove([x,y], [x+shiftX,y],
+            {c:pawnColor,p:piece}));
+        }
+        // Next condition because pawns on 1st rank can generally jump
+        if ([startRank,firstRank].includes(x)
+          && 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])
+      {
+        if (y + shiftY >= 0 && y + shiftY < sizeY
+          && this.board[x+shiftX][y+shiftY] != V.EMPTY
+          && this.canTake([x,y], [x+shiftX,y+shiftY]))
+        {
+          for (let piece of finalPieces)
+          {
+            moves.push(this.getBasicMove([x,y], [x+shiftX,y+shiftY],
+              {c:pawnColor,p:piece}));
+          }
+        }
+      }
+    }
+
+    if (V.HasEnpassant)
+    {
+      // En passant
+      const Lep = this.epSquares.length;
+      const epSquare = this.epSquares[Lep-1]; //always at least one element
+      if (!!epSquare && epSquare.x == x+shiftX && Math.abs(epSquare.y - y) == 1)
+      {
+        let enpassantMove = this.getBasicMove([x,y], [epSquare.x,epSquare.y]);
+        enpassantMove.vanish.push({
+          x: x,
+          y: epSquare.y,
+          p: 'p',
+          c: this.getColor(x,epSquare.y)
+        });
+        moves.push(enpassantMove);
+      }
+    }
+
+    return moves;
+  }
+
+  // What are the rook moves from square x,y ?
+  getPotentialRookMoves(sq)
+  {
+    return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]);
+  }
+
+  // What are the knight moves from square x,y ?
+  getPotentialKnightMoves(sq)
+  {
+    return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep");
+  }
+
+  // What are the bishop moves from square x,y ?
+  getPotentialBishopMoves(sq)
+  {
+    return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]);
+  }
+
+  // What are the queen moves from square x,y ?
+  getPotentialQueenMoves(sq)
+  {
+    return this.getSlideNJumpMoves(sq,
+      V.steps[V.ROOK].concat(V.steps[V.BISHOP]));
+  }
+
+  // What are the king moves from square x,y ?
+  getPotentialKingMoves(sq)
+  {
+    // Initialize with normal moves
+    let moves = this.getSlideNJumpMoves(sq,
+      V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
+    return moves.concat(this.getCastleMoves(sq));
+  }
+
+  getCastleMoves([x,y])
+  {
+    const c = this.getColor(x,y);
+    if (x != (c=="w" ? V.size.x-1 : 0) || y != this.INIT_COL_KING[c])
+      return []; //x isn't first rank, or king has moved (shortcut)
+
+    // Castling ?
+    const oppCol = V.GetOppCol(c);
+    let moves = [];
+    let i = 0;
+    const finalSquares = [ [2,3], [V.size.y-2,V.size.y-3] ]; //king, then rook
+    castlingCheck:
+    for (let castleSide=0; castleSide < 2; castleSide++) //large, then small
+    {
+      if (!this.castleFlags[c][castleSide])
+        continue;
+      // If this code is reached, rooks and king are on initial position
+
+      // Nothing on the path of the king ?
+      // (And no checks; OK also if y==finalSquare)
+      let step = finalSquares[castleSide][0] < y ? -1 : 1;
+      for (i=y; i!=finalSquares[castleSide][0]; i+=step)
+      {
+        if (this.isAttacked([x,i], [oppCol]) || (this.board[x][i] != V.EMPTY &&
+          // NOTE: next check is enough, because of chessboard constraints
+          (this.getColor(x,i) != c
+            || ![V.KING,V.ROOK].includes(this.getPiece(x,i)))))
+        {
+          continue castlingCheck;
+        }
+      }
+
+      // Nothing on the path to the rook?
+      step = castleSide == 0 ? -1 : 1;
+      for (i = y + step; i != this.INIT_COL_ROOK[c][castleSide]; i += step)
+      {
+        if (this.board[x][i] != V.EMPTY)
+          continue castlingCheck;
+      }
+      const rookPos = this.INIT_COL_ROOK[c][castleSide];
+
+      // Nothing on final squares, except maybe king and castling rook?
+      for (i=0; i<2; i++)
+      {
+        if (this.board[x][finalSquares[castleSide][i]] != V.EMPTY &&
+          this.getPiece(x,finalSquares[castleSide][i]) != V.KING &&
+          finalSquares[castleSide][i] != rookPos)
+        {
+          continue castlingCheck;
+        }
+      }
+
+      // If this code is reached, castle is valid
+      moves.push( new Move({
+        appear: [
+          new PiPo({x:x,y:finalSquares[castleSide][0],p:V.KING,c:c}),
+          new PiPo({x:x,y:finalSquares[castleSide][1],p:V.ROOK,c:c})],
+        vanish: [
+          new PiPo({x:x,y:y,p:V.KING,c:c}),
+          new PiPo({x:x,y:rookPos,p:V.ROOK,c:c})],
+        end: Math.abs(y - rookPos) <= 2
+          ? {x:x, y:rookPos}
+          : {x:x, y:y + 2 * (castleSide==0 ? -1 : 1)}
+      }) );
+    }
+
+    return moves;
+  }
+
+  ////////////////////
+  // MOVES VALIDATION
+
+  // For the interface: possible moves for the current turn from square sq
+  getPossibleMovesFrom(sq)
+  {
+    return this.filterValid( this.getPotentialMovesFrom(sq) );
+  }
+
+  // TODO: promotions (into R,B,N,Q) should be filtered only once
+  filterValid(moves)
+  {
+    if (moves.length == 0)
+      return [];
+    const color = this.turn;
+    return moves.filter(m => {
+      this.play(m);
+      const res = !this.underCheck(color);
+      this.undo(m);
+      return res;
+    });
+  }
+
+  // Search for all valid moves considering current turn
+  // (for engine and game end)
+  getAllValidMoves()
+  {
+    const color = this.turn;
+    const oppCol = V.GetOppCol(color);
+    let potentialMoves = [];
+    for (let i=0; i<V.size.x; i++)
+    {
+      for (let j=0; j<V.size.y; j++)
+      {
+        // Next condition "!= oppCol" to work with checkered variant
+        if (this.board[i][j] != V.EMPTY && this.getColor(i,j) != oppCol)
+        {
+          Array.prototype.push.apply(potentialMoves,
+            this.getPotentialMovesFrom([i,j]));
+        }
+      }
+    }
+    return this.filterValid(potentialMoves);
+  }
+
+  // Stop at the first move found
+  atLeastOneMove()
+  {
+    const color = this.turn;
+    const oppCol = V.GetOppCol(color);
+    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 && this.getColor(i,j) != oppCol)
+        {
+          const moves = this.getPotentialMovesFrom([i,j]);
+          if (moves.length > 0)
+          {
+            for (let k=0; k<moves.length; k++)
+            {
+              if (this.filterValid([moves[k]]).length > 0)
+                return true;
+            }
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  // Check if pieces of color in 'colors' are attacking (king) on square x,y
+  isAttacked(sq, colors)
+  {
+    return (this.isAttackedByPawn(sq, colors)
+      || this.isAttackedByRook(sq, colors)
+      || this.isAttackedByKnight(sq, colors)
+      || this.isAttackedByBishop(sq, colors)
+      || this.isAttackedByQueen(sq, colors)
+      || this.isAttackedByKing(sq, colors));
+  }
+
+  // Is square x,y attacked by 'colors' pawns ?
+  isAttackedByPawn([x,y], colors)
+  {
+    for (let c of colors)
+    {
+      let pawnShift = (c=="w" ? 1 : -1);
+      if (x+pawnShift>=0 && x+pawnShift<V.size.x)
+      {
+        for (let i of [-1,1])
+        {
+          if (y+i>=0 && y+i<V.size.y && this.getPiece(x+pawnShift,y+i)==V.PAWN
+            && this.getColor(x+pawnShift,y+i)==c)
+          {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  // Is square x,y attacked by 'colors' rooks ?
+  isAttackedByRook(sq, colors)
+  {
+    return this.isAttackedBySlideNJump(sq, colors, V.ROOK, V.steps[V.ROOK]);
+  }
+
+  // Is square x,y attacked by 'colors' knights ?
+  isAttackedByKnight(sq, colors)
+  {
+    return this.isAttackedBySlideNJump(sq, colors,
+      V.KNIGHT, V.steps[V.KNIGHT], "oneStep");
+  }
+
+  // Is square x,y attacked by 'colors' bishops ?
+  isAttackedByBishop(sq, colors)
+  {
+    return this.isAttackedBySlideNJump(sq, colors, V.BISHOP, V.steps[V.BISHOP]);
+  }
+
+  // Is square x,y attacked by 'colors' queens ?
+  isAttackedByQueen(sq, colors)
+  {
+    return this.isAttackedBySlideNJump(sq, colors, V.QUEEN,
+      V.steps[V.ROOK].concat(V.steps[V.BISHOP]));
+  }
+
+  // Is square x,y attacked by 'colors' king(s) ?
+  isAttackedByKing(sq, colors)
+  {
+    return this.isAttackedBySlideNJump(sq, colors, V.KING,
+      V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
+  }
+
+  // Generic method for non-pawn pieces ("sliding or jumping"):
+  // is x,y attacked by a piece of color in array 'colors' ?
+  isAttackedBySlideNJump([x,y], colors, piece, steps, oneStep)
+  {
+    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 && !oneStep)
+      {
+        rx += step[0];
+        ry += step[1];
+      }
+      if (V.OnBoard(rx,ry) && this.getPiece(rx,ry) === piece
+        && colors.includes(this.getColor(rx,ry)))
+      {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Is color under check after his move ?
+  underCheck(color)
+  {
+    return this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]);
+  }
+
+  /////////////////
+  // MOVES PLAYING
+
+  // Apply a move on board
+  static PlayOnBoard(board, move)
+  {
+    for (let psq of move.vanish)
+      board[psq.x][psq.y] = V.EMPTY;
+    for (let psq of move.appear)
+      board[psq.x][psq.y] = psq.c + psq.p;
+  }
+  // Un-apply the played move
+  static UndoOnBoard(board, move)
+  {
+    for (let psq of move.appear)
+      board[psq.x][psq.y] = V.EMPTY;
+    for (let psq of move.vanish)
+      board[psq.x][psq.y] = psq.c + psq.p;
+  }
+
+  // After move is played, update variables + flags
+  updateVariables(move)
+  {
+    let piece = undefined;
+    let c = undefined;
+    if (move.vanish.length >= 1)
+    {
+      // Usual case, something is moved
+      piece = move.vanish[0].p;
+      c = move.vanish[0].c;
+    }
+    else
+    {
+      // Crazyhouse-like variants
+      piece = move.appear[0].p;
+      c = move.appear[0].c;
+    }
+    if (c == "c") //if (!["w","b"].includes(c))
+    {
+      // 'c = move.vanish[0].c' doesn't work for Checkered
+      c = V.GetOppCol(this.turn);
+    }
+    const firstRank = (c == "w" ? V.size.x-1 : 0);
+
+    // Update king position + flags
+    if (piece == V.KING && move.appear.length > 0)
+    {
+      this.kingPos[c][0] = move.appear[0].x;
+      this.kingPos[c][1] = move.appear[0].y;
+      if (V.HasFlags)
+        this.castleFlags[c] = [false,false];
+      return;
+    }
+    if (V.HasFlags)
+    {
+      // Update castling flags if rooks are moved
+      const oppCol = V.GetOppCol(c);
+      const oppFirstRank = (V.size.x-1) - firstRank;
+      if (move.start.x == firstRank //our rook moves?
+        && this.INIT_COL_ROOK[c].includes(move.start.y))
+      {
+        const flagIdx = (move.start.y == this.INIT_COL_ROOK[c][0] ? 0 : 1);
+        this.castleFlags[c][flagIdx] = false;
+      }
+      else if (move.end.x == oppFirstRank //we took opponent rook?
+        && this.INIT_COL_ROOK[oppCol].includes(move.end.y))
+      {
+        const flagIdx = (move.end.y == this.INIT_COL_ROOK[oppCol][0] ? 0 : 1);
+        this.castleFlags[oppCol][flagIdx] = false;
+      }
+    }
+  }
+
+  // After move is undo-ed *and flags resetted*, un-update other variables
+  // TODO: more symmetry, by storing flags increment in move (?!)
+  unupdateVariables(move)
+  {
+    // (Potentially) Reset king position
+    const c = this.getColor(move.start.x,move.start.y);
+    if (this.getPiece(move.start.x,move.start.y) == V.KING)
+      this.kingPos[c] = [move.start.x, move.start.y];
+  }
+
+  play(move)
+  {
+    // DEBUG:
+//    if (!this.states) this.states = [];
+//    const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
+//    this.states.push(stateFen);
+
+    if (V.HasFlags)
+      move.flags = JSON.stringify(this.aggregateFlags()); //save flags (for undo)
+    if (V.HasEnpassant)
+      this.epSquares.push( this.getEpSquare(move) );
+    if (!move.color)
+      move.color = this.turn; //for interface
+    V.PlayOnBoard(this.board, move);
+    this.turn = V.GetOppCol(this.turn);
+    this.movesCount++;
+    this.updateVariables(move);
+  }
+
+  undo(move)
+  {
+    if (V.HasEnpassant)
+      this.epSquares.pop();
+    if (V.HasFlags)
+      this.disaggregateFlags(JSON.parse(move.flags));
+    V.UndoOnBoard(this.board, move);
+    this.turn = V.GetOppCol(this.turn);
+    this.movesCount--;
+    this.unupdateVariables(move);
+
+    // DEBUG:
+//    const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
+//    if (stateFen != this.states[this.states.length-1]) debugger;
+//    this.states.pop();
+  }
+
+  ///////////////
+  // END OF GAME
+
+  // What is the score ? (Interesting if game is over)
+  getCurrentScore()
+  {
+    if (this.atLeastOneMove()) // game not over
+      return "*";
+
+    // Game over
+    const color = this.turn;
+    // No valid move: stalemate or checkmate?
+    if (!this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]))
+      return "1/2";
+    // OK, checkmate
+    return (color == "w" ? "0-1" : "1-0");
+  }
+
+  ///////////////
+  // ENGINE PLAY
+
+  // Pieces values
+  static get VALUES()
+  {
+    return {
+      'p': 1,
+      'r': 5,
+      'n': 3,
+      'b': 3,
+      'q': 9,
+      'k': 1000
+    };
+  }
+
+  // "Checkmate" (unreachable eval)
+  static get INFINITY() { return 9999; }
+
+  // At this value or above, the game is over
+  static get THRESHOLD_MATE() { return V.INFINITY; }
+
+  // Search depth: 2 for high branching factor, 4 for small (Loser chess, eg.)
+  static get SEARCH_DEPTH() { return 3; }
+
+  // Assumption: at least one legal move
+  // NOTE: works also for extinction chess because depth is 3...
+  getComputerMove()
+  {
+    const maxeval = V.INFINITY;
+    const color = this.turn;
+    // Some variants may show a bigger moves list to the human (Switching),
+    // thus the argument "computer" below (which is generally ignored)
+    let moves1 = this.getAllValidMoves("computer");
+
+    // Can I mate in 1 ? (for Magnetic & Extinction)
+    for (let i of shuffle(ArrayFun.range(moves1.length)))
+    {
+      this.play(moves1[i]);
+      let finish = (Math.abs(this.evalPosition()) >= V.THRESHOLD_MATE);
+      if (!finish)
+      {
+        const score = this.getCurrentScore();
+        if (["1-0","0-1"].includes(score))
+          finish = true;
+      }
+      this.undo(moves1[i]);
+      if (finish)
+        return moves1[i];
+    }
+
+    // Rank moves using a min-max at depth 2
+    for (let i=0; i<moves1.length; i++)
+    {
+      // Initial self evaluation is very low: "I'm checkmated"
+      moves1[i].eval = (color=="w" ? -1 : 1) * maxeval;
+      this.play(moves1[i]);
+      const score1 = this.getCurrentScore();
+      let eval2 = undefined;
+      if (score1 == "*")
+      {
+        // Initial enemy evaluation is very low too, for him
+        eval2 = (color=="w" ? 1 : -1) * maxeval;
+        // Second half-move:
+        let moves2 = this.getAllValidMoves("computer");
+        for (let j=0; j<moves2.length; j++)
+        {
+          this.play(moves2[j]);
+          const score2 = this.getCurrentScore();
+          const evalPos = score2 == "*"
+            ? this.evalPosition()
+            : (score2=="1/2" ? 0 : (score2=="1-0" ? 1 : -1) * maxeval);
+          if ((color == "w" && evalPos < eval2)
+            || (color=="b" && evalPos > eval2))
+          {
+            eval2 = evalPos;
+          }
+          this.undo(moves2[j]);
+        }
+      }
+      else
+        eval2 = (score1=="1/2" ? 0 : (score1=="1-0" ? 1 : -1) * maxeval);
+      if ((color=="w" && eval2 > moves1[i].eval)
+        || (color=="b" && eval2 < moves1[i].eval))
+      {
+        moves1[i].eval = eval2;
+      }
+      this.undo(moves1[i]);
+    }
+    moves1.sort( (a,b) => { return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
+
+    let candidates = [0]; //indices of candidates moves
+    for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
+      candidates.push(j);
+    let currentBest = moves1[sample(candidates)];
+
+    // From here, depth >= 3: may take a while, so we control time
+    const timeStart = Date.now();
+
+    // Skip depth 3+ if we found a checkmate (or if we are checkmated in 1...)
+    if (V.SEARCH_DEPTH >= 3 && Math.abs(moves1[0].eval) < V.THRESHOLD_MATE)
+    {
+      for (let i=0; i<moves1.length; i++)
+      {
+        if (Date.now()-timeStart >= 5000) //more than 5 seconds
+          return currentBest; //depth 2 at least
+        this.play(moves1[i]);
+        // 0.1 * oldEval : heuristic to avoid some bad moves (not all...)
+        moves1[i].eval = 0.1*moves1[i].eval +
+          this.alphabeta(V.SEARCH_DEPTH-1, -maxeval, maxeval);
+        this.undo(moves1[i]);
+      }
+      moves1.sort( (a,b) => {
+        return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
+    }
+    else
+      return currentBest;
+//    console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
+
+    candidates = [0];
+    for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
+      candidates.push(j);
+    return moves1[sample(candidates)];
+  }
+
+  alphabeta(depth, alpha, beta)
+  {
+    const maxeval = V.INFINITY;
+    const color = this.turn;
+    const score = this.getCurrentScore();
+    if (score != "*")
+      return (score=="1/2" ? 0 : (score=="1-0" ? 1 : -1) * maxeval);
+    if (depth == 0)
       return this.evalPosition();
-		const moves = this.getAllValidMoves("computer");
+    const moves = this.getAllValidMoves("computer");
     let v = color=="w" ? -maxeval : maxeval;
-		if (color == "w")
-		{
-			for (let i=0; i<moves.length; i++)
+    if (color == "w")
+    {
+      for (let i=0; i<moves.length; i++)
+      {
+        this.play(moves[i]);
+        v = Math.max(v, this.alphabeta(depth-1, alpha, beta));
+        this.undo(moves[i]);
+        alpha = Math.max(alpha, v);
+        if (alpha >= beta)
+          break; //beta cutoff
+      }
+    }
+    else //color=="b"
+    {
+      for (let i=0; i<moves.length; i++)
+      {
+        this.play(moves[i]);
+        v = Math.min(v, this.alphabeta(depth-1, alpha, beta));
+        this.undo(moves[i]);
+        beta = Math.min(beta, v);
+        if (alpha >= beta)
+          break; //alpha cutoff
+      }
+    }
+    return v;
+  }
+
+  evalPosition()
+  {
+    let evaluation = 0;
+    // Just count material for now
+    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)
+        {
+          const sign = this.getColor(i,j) == "w" ? 1 : -1;
+          evaluation += sign * V.VALUES[this.getPiece(i,j)];
+        }
+      }
+    }
+    return evaluation;
+  }
+
+  /////////////////////////
+  // MOVES + GAME NOTATION
+  /////////////////////////
+
+  // Context: just before move is played, turn hasn't changed
+  // TODO: un-ambiguous notation (switch on piece type, check directions...)
+  getNotation(move)
+  {
+    if (move.appear.length == 2 && move.appear[0].p == V.KING) //castle
+      return (move.end.y < move.start.y ? "0-0-0" : "0-0");
+
+    // Translate final square
+    const finalSquare = V.CoordsToSquare(move.end);
+
+    const piece = this.getPiece(move.start.x, move.start.y);
+    if (piece == V.PAWN)
+    {
+      // Pawn move
+      let notation = "";
+      if (move.vanish.length > move.appear.length)
       {
-				this.play(moves[i]);
-				v = Math.max(v, this.alphabeta(depth-1, alpha, beta));
-				this.undo(moves[i]);
-				alpha = Math.max(alpha, v);
-				if (alpha >= beta)
-					break; //beta cutoff
-			}
-		}
-		else //color=="b"
-		{
-			for (let i=0; i<moves.length; i++)
-			{
-				this.play(moves[i]);
-				v = Math.min(v, this.alphabeta(depth-1, alpha, beta));
-				this.undo(moves[i]);
-				beta = Math.min(beta, v);
-				if (alpha >= beta)
-					break; //alpha cutoff
-			}
-		}
-		return v;
-	}
-
-	evalPosition()
-	{
-		let evaluation = 0;
-		// Just count material for now
-		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)
-				{
-					const sign = this.getColor(i,j) == "w" ? 1 : -1;
-					evaluation += sign * V.VALUES[this.getPiece(i,j)];
-				}
-			}
-		}
-		return evaluation;
-	}
-
-	/////////////////////////
-	// MOVES + GAME NOTATION
-	/////////////////////////
-
-	// Context: just before move is played, turn hasn't changed
-	// TODO: un-ambiguous notation (switch on piece type, check directions...)
-	getNotation(move)
-	{
-		if (move.appear.length == 2 && move.appear[0].p == V.KING) //castle
-			return (move.end.y < move.start.y ? "0-0-0" : "0-0");
-
-		// Translate final square
-		const finalSquare = V.CoordsToSquare(move.end);
-
-		const piece = this.getPiece(move.start.x, move.start.y);
-		if (piece == V.PAWN)
-		{
-			// Pawn move
-			let notation = "";
-			if (move.vanish.length > move.appear.length)
-			{
-				// Capture
-				const startColumn = V.CoordToColumn(move.start.y);
-				notation = startColumn + "x" + finalSquare;
-			}
-			else //no capture
-				notation = finalSquare;
-			if (move.appear.length > 0 && move.appear[0].p != V.PAWN) //promotion
-				notation += "=" + move.appear[0].p.toUpperCase();
-			return notation;
-		}
-
-		else
-		{
-			// Piece movement
-			return piece.toUpperCase() +
-				(move.vanish.length > move.appear.length ? "x" : "") + finalSquare;
-		}
-	}
+        // Capture
+        const startColumn = V.CoordToColumn(move.start.y);
+        notation = startColumn + "x" + finalSquare;
+      }
+      else //no capture
+        notation = finalSquare;
+      if (move.appear.length > 0 && move.appear[0].p != V.PAWN) //promotion
+        notation += "=" + move.appear[0].p.toUpperCase();
+      return notation;
+    }
+
+    else
+    {
+      // Piece movement
+      return piece.toUpperCase() +
+        (move.vanish.length > move.appear.length ? "x" : "") + finalSquare;
+    }
+  }
 }
diff --git a/client/src/components/ComputerGame.vue b/client/src/components/ComputerGame.vue
index b3db07f9..2070cd09 100644
--- a/client/src/components/ComputerGame.vue
+++ b/client/src/components/ComputerGame.vue
@@ -75,6 +75,7 @@ export default {
       const vModule = await import("@/variants/" + this.vname + ".js");
       window.V = vModule.VariantRules;
       this.compWorker.postMessage(["scripts",this.vname]);
+      this.compWorker.postMessage(["init",this.fen]);
       this.newGameFromFen(this.fen);
     },
     newGameFromFen: function(fen) {
@@ -93,7 +94,7 @@ export default {
         this.mycolor = (Math.random() < 0.5 ? "w" : "b");
         this.orientation = this.mycolor;
         this.compWorker.postMessage(["init",fen]);
-        if (this.mycolor != "w" || this.subMode == "auto")
+        if (this.mycolor != "w" || this.mode == "auto")
           this.playComputerMove();
       }
     },
diff --git a/client/src/playCompMove.js b/client/src/playCompMove.js
index ddaeba38..062eae35 100644
--- a/client/src/playCompMove.js
+++ b/client/src/playCompMove.js
@@ -5,22 +5,22 @@
 //self.addEventListener('message', (e) =>
 onmessage = async function(e)
 {
-	switch (e.data[0])
-	{
-		case "scripts":
+  switch (e.data[0])
+  {
+    case "scripts":
       const vModule = await import("@/variants/" + e.data[1] + ".js");
-			self.V = vModule.VariantRules;
-			break;
-		case "init":
-			const fen = e.data[1];
-			self.vr = new self.V(fen);
-			break;
-		case "newmove":
-			self.vr.play(e.data[1]);
-			break;
-		case "askmove":
-			const compMove = self.vr.getComputerMove();
-			postMessage(compMove);
-			break;
-	}
+      self.V = vModule.VariantRules;
+      break;
+    case "init":
+      const fen = e.data[1];
+      self.vr = new self.V(fen);
+      break;
+    case "newmove":
+      self.vr.play(e.data[1]);
+      break;
+    case "askmove":
+      const compMove = self.vr.getComputerMove();
+      postMessage(compMove);
+      break;
+  }
 }
diff --git a/client/src/variants/Alice.js b/client/src/variants/Alice.js
index 2feb8b8f..e80e13b6 100644
--- a/client/src/variants/Alice.js
+++ b/client/src/variants/Alice.js
@@ -2,6 +2,7 @@ import { ChessRules } from "@/base_rules";
 import { ArrayFun} from "@/utils/array";
 
 // NOTE: alternative implementation, probably cleaner = use only 1 board
+// TODO? atLeastOneMove() would be more efficient if rewritten here (less sideBoard computations)
 export const VariantRules = class AliceRules extends ChessRules
 {
 	static get ALICE_PIECES()
@@ -98,12 +99,14 @@ export const VariantRules = class AliceRules extends ChessRules
 		const pieces = Object.keys(V.ALICE_CODES);
 		const codes = Object.keys(V.ALICE_PIECES);
 		const mirrorSide = (pieces.includes(this.getPiece(x,y)) ? 1 : 2);
+    if (!sideBoard)
+	    sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
 		const color = this.getColor(x,y);
 
 		// Search valid moves on sideBoard
-		let saveBoard = this.board;
-		this.board = sideBoard || this.getSideBoard(mirrorSide);
-		let moves = super.getPotentialMovesFrom([x,y])
+		const saveBoard = this.board;
+		this.board = sideBoard[mirrorSide-1];
+		const moves = super.getPotentialMovesFrom([x,y])
 			.filter(m => {
 				// Filter out king moves which result in under-check position on
 				// current board (before mirror traversing)
@@ -111,7 +114,7 @@ export const VariantRules = class AliceRules extends ChessRules
 				if (m.appear[0].p == V.KING)
 				{
 					this.play(m);
-					if (this.underCheck(color))
+					if (this.underCheck(color, sideBoard))
 						aprioriValid = false;
 					this.undo(m);
 				}
@@ -120,7 +123,7 @@ export const VariantRules = class AliceRules extends ChessRules
 		this.board = saveBoard;
 
 		// Finally filter impossible moves
-		let res = moves.filter(m => {
+		const res = moves.filter(m => {
 			if (m.appear.length == 2) //castle
 			{
 				// appear[i] must be an empty square on the other board
@@ -172,11 +175,12 @@ export const VariantRules = class AliceRules extends ChessRules
 		return res;
 	}
 
-	filterValid(moves)
+	filterValid(moves, sideBoard)
 	{
 		if (moves.length == 0)
 			return [];
-		let sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
+		if (!sideBoard)
+      sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
 		const color = this.turn;
 		return moves.filter(m => {
 			this.playSide(m, sideBoard); //no need to track flags
@@ -190,20 +194,16 @@ export const VariantRules = class AliceRules extends ChessRules
 	{
 		const color = this.turn;
 		const oppCol = V.GetOppCol(color);
-		var potentialMoves = [];
-		let sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
+		let potentialMoves = [];
+		const sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
 		for (var i=0; i<V.size.x; i++)
 		{
 			for (var j=0; j<V.size.y; j++)
 			{
 				if (this.board[i][j] != V.EMPTY && this.getColor(i,j) == color)
 				{
-					const mirrorSide =
-						Object.keys(V.ALICE_CODES).includes(this.getPiece(i,j))
-							? 1
-							: 2;
 					Array.prototype.push.apply(potentialMoves,
-						this.getPotentialMovesFrom([i,j], sideBoard[mirrorSide-1]));
+						this.getPotentialMovesFrom([i,j], sideBoard));
 				}
 			}
 		}
@@ -244,7 +244,8 @@ export const VariantRules = class AliceRules extends ChessRules
 		});
 	}
 
-	underCheck(color, sideBoard) //sideBoard arg always provided
+  // sideBoard: arg containing both boards (see getAllValidMoves())
+	underCheck(color, sideBoard)
 	{
 		const kp = this.kingPos[color];
 		const mirrorSide = (sideBoard[0][kp[0]][kp[1]] != V.EMPTY ? 1 : 2);