[vchess.git] / public / javascripts / variants / Ultima.js

class UltimaRules extends ChessRules
{
	static getPpath(b)
	{
		if (b[1] == "m") //'m' for Immobilizer (I is too similar to 1)
			return "Ultima/" + b;
		return b; //usual piece
	}

	initVariables(fen)
	{
		this.kingPos = {'w':[-1,-1], 'b':[-1,-1]};
		const fenParts = fen.split(" ");
		const position = fenParts[0].split("/");
		for (let i=0; i<position.length; i++)
		{
			let k = 0;
			for (let j=0; j<position[i].length; j++)
			{
				switch (position[i].charAt(j))
				{
					case 'k':
						this.kingPos['b'] = [i,k];
						break;
					case 'K':
						this.kingPos['w'] = [i,k];
						break;
					default:
						let num = parseInt(position[i].charAt(j));
						if (!isNaN(num))
							k += (num-1);
				}
				k++;
			}
		}
		this.epSquares = []; //no en-passant here
	}

	setFlags(fen)
	{
		// TODO: for compatibility?
		this.castleFlags = {"w":[false,false], "b":[false,false]};
	}

	static get IMMOBILIZER() { return 'm'; }
	// Although other pieces keep their names here for coding simplicity,
	// keep in mind that:
	//  - a "rook" is a coordinator, capturing by coordinating with the king
	//  - a "knight" is a long-leaper, capturing as in draughts
	//  - a "bishop" is a chameleon, capturing as its prey
	//  - a "queen" is a withdrawer, capturing by moving away from pieces

	getPotentialMovesFrom([x,y])
	{
		// Pre-check: is thing on this square immobilized?
		const piece = this.getPiece(x,y);
		const color = this.getColor(x,y);
		const oppCol = this.getOppCol(color);
		const V = VariantRules;
		const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
		const [sizeX,sizeY] = V.size;
		outerLoop:
		for (let step of adjacentSteps)
		{
			const [i,j] = [x+step[0],y+step[1]];
			if (i>=0 && i<sizeX && j>=0 && j<sizeY && this.board[i][j] != V.EMPTY
				&& this.getColor(i,j) == oppCol)
			{
				const oppPiece = this.getPiece(i,j);
				if (oppPiece == V.BISHOP && piece == V.IMMOBILIZER)
					return [];
				if (oppPiece == V.IMMOBILIZER && ![V.BISHOP,V.IMMOBILIZER].includes(piece))
				{
					// Moving is impossible only if this immobilizer is not neutralized
					for (let step2 of adjacentSteps)
					{
						const [i2,j2] = [i+step2[0],j+step2[1]];
						if (i2>=0 && i2<sizeX && j2>=0 && j2<sizeY
							&& this.board[i2][j2] != V.EMPTY && this.getColor(i2,j2) == color)
						{
							const friendlyPiece = this.getPiece(i2,j2);
							if ([V.BISHOP,V.IMMOBILIZER].includes(friendlyPiece))
								break outerLoop;
						}
					}
					return []; //immobilizer isn't neutralized
				}
			}
		}
		switch (this.getPiece(x,y))
		{
			case VariantRules.IMMOBILIZER:
				return this.getPotentialImmobilizerMoves([x,y]);
			default:
				return super.getPotentialMovesFrom([x,y]);
		}
	}

	getSlideNJumpMoves([x,y], steps, oneStep)
	{
		const color = this.getColor(x,y);
		const piece = this.getPiece(x,y);
		let moves = [];
		const [sizeX,sizeY] = VariantRules.size;
		outerLoop:
		for (let step of steps)
		{
			let i = x + step[0];
			let j = y + step[1];
			while (i>=0 && i<sizeX && j>=0 && j<sizeY
				&& this.board[i][j] == VariantRules.EMPTY)
			{
				moves.push(this.getBasicMove([x,y], [i,j]));
				if (oneStep !== undefined)
					continue outerLoop;
				i += step[0];
				j += step[1];
			}
			// Only king can take on occupied square:
			if (piece==VariantRules.KING && i>=0 && i<sizeX && j>=0
				&& j<sizeY && this.canTake([x,y], [i,j]))
			{
				moves.push(this.getBasicMove([x,y], [i,j]));
			}
		}
		return moves;
	}

	// Modify capturing moves among listed pawn moves
	addPawnCaptures(moves, byChameleon)
	{
		const steps = VariantRules.steps[VariantRules.ROOK];
		const [sizeX,sizeY] = VariantRules.size;
		const color = this.turn;
		const oppCol = this.getOppCol(color);
		moves.forEach(m => {
			if (!!byChameleon && m.start.x!=m.end.x && m.start.y!=m.end.y)
				return; //chameleon not moving as pawn
			// Try capturing in every direction
			for (let step of steps)
			{
				const sq2 = [m.end.x+2*step[0],m.end.y+2*step[1]];
				if (sq2[0]>=0 && sq2[0]<sizeX && sq2[1]>=0 && sq2[1]<sizeY
					&& this.board[sq2[0]][sq2[1]] != VariantRules.EMPTY
					&& this.getColor(sq2[0],sq2[1]) == color)
				{
					// Potential capture
					const sq1 = [m.end.x+step[0],m.end.y+step[1]];
					if (this.board[sq1[0]][sq1[1]] != VariantRules.EMPTY
						&& this.getColor(sq1[0],sq1[1]) == oppCol)
					{
						const piece1 = this.getPiece(sq1[0],sq1[1]);
						if (!byChameleon || piece1 == VariantRules.PAWN)
						{
							m.vanish.push(new PiPo({
								x:sq1[0],
								y:sq1[1],
								c:oppCol,
								p:piece1
							}));
						}
					}
				}
			}
		});
	}

	// "Pincher"
	getPotentialPawnMoves([x,y])
	{
		let moves = super.getPotentialRookMoves([x,y]);
		this.addPawnCaptures(moves);
		return moves;
	}

	addRookCaptures(moves, byChameleon)
	{
		const color = this.turn;
		const oppCol = this.getOppCol(color);
		const kp = this.kingPos[color];
		moves.forEach(m => {
			// Check piece-king rectangle (if any) corners for enemy pieces
			if (m.end.x == kp[0] || m.end.y == kp[1])
				return; //"flat rectangle"
			const corner1 = [Math.max(m.end.x,kp[0]), Math.min(m.end.y,kp[1])];
			const corner2 = [Math.min(m.end.x,kp[0]), Math.max(m.end.y,kp[1])];
			for (let [i,j] of [corner1,corner2])
			{
				if (this.board[i][j] != VariantRules.EMPTY && this.getColor(i,j) == oppCol)
				{
					const piece = this.getPiece(i,j);
					if (!byChameleon || piece == VariantRules.ROOK)
					{
						m.vanish.push( new PiPo({
							x:i,
							y:j,
							p:piece,
							c:oppCol
						}) );
					}
				}
			}
		});
	}

	// Coordinator
	getPotentialRookMoves(sq)
	{
		let moves = super.getPotentialQueenMoves(sq);
		this.addRookCaptures(moves);
		return moves;
	}

	// Long-leaper
	getKnightCaptures(startSquare, byChameleon)
	{
		// Look in every direction for captures
		const V = VariantRules;
		const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
		const [sizeX,sizeY] = V.size;
		const color = this.turn;
		const oppCol = this.getOppCol(color);
		let moves = [];
		const [x,y] = [startSquare[0],startSquare[1]];
		const piece = this.getPiece(x,y); //might be a chameleon!
		outerLoop:
		for (let step of steps)
		{
			let [i,j] = [x+step[0], y+step[1]];
			while (i>=0 && i<sizeX && j>=0 && j<sizeY && this.board[i][j]==V.EMPTY)
			{
				i += step[0];
				j += step[1];
			}
			if (i<0 || i>=sizeX || j<0 || j>=sizeY || this.getColor(i,j)==color
				|| (!!byChameleon && this.getPiece(i,j)!=V.KNIGHT))
			{
				continue;
			}
			// last(thing), cur(thing) : stop if "cur" is our color, or beyond board limits,
			// or if "last" isn't empty and cur neither. Otherwise, if cur is empty then
			// add move until cur square; if cur is occupied then stop if !!byChameleon and
			// the square not occupied by a leaper.
			let last = [i,j];
			let cur = [i+step[0],j+step[1]];
			let vanished = [ new PiPo({x:x,y:y,c:color,p:piece}) ];
			while (cur[0]>=0 && cur[0]<sizeX && cur[1]>=0 && cur[1]<sizeY)
			{
				if (this.board[last[0]][last[1]] != V.EMPTY)
				{
					const oppPiece = this.getPiece(last[0],last[1]);
					if (!!byChameleon && oppPiece != V.KNIGHT)
						continue outerLoop;
					// Something to eat:
					vanished.push( new PiPo({x:last[0],y:last[1],c:oppCol,p:oppPiece}) );
				}
				if (this.board[cur[0]][cur[1]] != V.EMPTY)
				{
					if (this.getColor(cur[0],cur[1]) == color
						|| this.board[last[0]][last[1]] != V.EMPTY) //TODO: redundant test
					{
						continue outerLoop;
					}
				}
				else
				{
					moves.push(new Move({
						appear: [ new PiPo({x:cur[0],y:cur[1],c:color,p:piece}) ],
						vanish: JSON.parse(JSON.stringify(vanished)), //TODO: required?
						start: {x:x,y:y},
						end: {x:cur[0],y:cur[1]}
					}));
				}
				last = [last[0]+step[0],last[1]+step[1]];
				cur = [cur[0]+step[0],cur[1]+step[1]];
			}
		}
		return moves;
	}

	// Long-leaper
	getPotentialKnightMoves(sq)
	{
		return super.getPotentialQueenMoves(sq).concat(this.getKnightCaptures(sq));
	}

	getPotentialBishopMoves([x,y])
	{
		let moves = super.getPotentialQueenMoves([x,y])
			.concat(this.getKnightCaptures([x,y],"asChameleon"));
		this.addPawnCaptures(moves, "asChameleon");
		this.addRookCaptures(moves, "asChameleon");
		this.addQueenCaptures(moves, "asChameleon");
		// Add king capture if it's within range
		const oppKp = this.kingPos[this.getOppCol(this.turn)];
		if (Math.abs(x-oppKp[0]) <= 1 && Math.abs(y-oppKp[1]) <= 1)
			moves.push(this.getBasicMove([x,y],oppKp));
		// Post-processing: merge similar moves, concatenating vanish arrays
		let mergedMoves = {};
		const [sizeX,sizeY] = VariantRules.size;
		moves.forEach(m => {
			const key = m.end.x + sizeX * m.end.y;
			if (!mergedMoves[key])
				mergedMoves[key] = m;
			else
			{
				for (let i=1; i<m.vanish.length; i++)
					mergedMoves[key].vanish.push(m.vanish[i]);
			}
		});
		// Finally return an array
		moves = [];
		Object.keys(mergedMoves).forEach(k => { moves.push(mergedMoves[k]); });
		return moves;
	}

	// Withdrawer
	addQueenCaptures(moves, byChameleon)
	{
		if (moves.length == 0)
			return;
		const [x,y] = [moves[0].start.x,moves[0].start.y];
		const V = VariantRules;
		const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
		let capturingDirections = [];
		const color = this.turn;
		const oppCol = this.getOppCol(color);
		const [sizeX,sizeY] = V.size;
		adjacentSteps.forEach(step => {
			const [i,j] = [x+step[0],y+step[1]];
			if (i>=0 && i<sizeX && j>=0 && j<sizeY
				&& this.board[i][j] != V.EMPTY && this.getColor(i,j) == oppCol
				&& (!byChameleon || this.getPiece(i,j) == V.QUEEN))
			{
				capturingDirections.push(step);
			}
		});
		moves.forEach(m => {
			const step = [
				m.end.x!=x ? (m.end.x-x)/Math.abs(m.end.x-x) : 0,
				m.end.y!=y ? (m.end.y-y)/Math.abs(m.end.y-y) : 0
			];
			// NOTE: includes() and even _.isEqual() functions fail...
			// TODO: this test should be done only once per direction
			if (capturingDirections.some(dir =>
				{ return (dir[0]==-step[0] && dir[1]==-step[1]); }))
			{
				const [i,j] = [x-step[0],y-step[1]];
				m.vanish.push(new PiPo({
					x:i,
					y:j,
					p:this.getPiece(i,j),
					c:oppCol
				}));
			}
		});
	}

	getPotentialQueenMoves(sq)
	{
		let moves = super.getPotentialQueenMoves(sq);
		this.addQueenCaptures(moves);
		return moves;
	}

	getPotentialImmobilizerMoves(sq)
	{
		// Immobilizer doesn't capture
		return super.getPotentialQueenMoves(sq);
	}

	getPotentialKingMoves(sq)
	{
		const V = VariantRules;
		return this.getSlideNJumpMoves(sq,
			V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
	}

	atLeastOneMove()
	{
		if (this.kingPos[this.turn][0] < 0)
			return false;
		return super.atLeastOneMove();
	}

	underCheck(move)
	{
		return false; //there is no check
	}

	getCheckSquares(move)
	{
		const c = this.getOppCol(this.turn); //opponent
		const saveKingPos = this.kingPos[c]; //king might be taken
		this.play(move);
		// The only way to be "under check" is to have lost the king (thus game over)
		let res = this.kingPos[c][0] < 0
			? [ JSON.parse(JSON.stringify(saveKingPos)) ]
			: [ ];
		this.undo(move);
		return res;
	}

	updateVariables(move)
	{
		// Just update king(s) position(s)
		const piece = this.getPiece(move.start.x,move.start.y);
		const c = this.getColor(move.start.x,move.start.y);
		if (piece == VariantRules.KING && move.appear.length > 0)
		{
			this.kingPos[c][0] = move.appear[0].x;
			this.kingPos[c][1] = move.appear[0].y;
		}
		// Does this move takes opponent's king?
		const oppCol = this.getOppCol(c);
		for (let i=1; i<move.vanish.length; i++)
		{
			if (move.vanish[i].p == VariantRules.KING)
			{
				this.kingPos[oppCol] = [-1,-1];
				break;
			}
		}
	}

	unupdateVariables(move)
	{
		super.unupdateVariables(move);
		const c = this.getColor(move.start.x,move.start.y);
		const oppCol = this.getOppCol(c);
		if (this.kingPos[oppCol][0] < 0)
		{
			// Last move took opponent's king
			for (let i=1; i<move.vanish.length; i++)
			{
				const psq = move.vanish[i];
				if (psq.p == 'k')
				{
					this.kingPos[oppCol] = [psq.x, psq.y];
					break;
				}
			}
		}
	}

	checkGameEnd()
	{
		// Stalemate, or our king disappeared
		return this.turn == "w" ? "0-1" : "1-0";
	}

	static get VALUES() { //TODO: totally experimental!
		return {
			'p': 1,
			'r': 2,
			'n': 5,
			'b': 3,
			'q': 3,
			'm': 5,
			'k': 1000
		};
	}

	static get SEARCH_DEPTH() { return 2; } //TODO?

	static get THRESHOLD_MATE() {
		return 500; //checkmates evals may be slightly below 1000
	}

	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 = _.range(8);
			// Get random squares for every piece, totally freely

			let randIndex = _.random(7);
			const bishop1Pos = positions[randIndex];
			positions.splice(randIndex, 1);

			randIndex = _.random(6);
			const bishop2Pos = positions[randIndex];
			positions.splice(randIndex, 1);

			randIndex = _.random(5);
			const knight1Pos = positions[randIndex];
			positions.splice(randIndex, 1);

			randIndex = _.random(4);
			const knight2Pos = positions[randIndex];
			positions.splice(randIndex, 1);

			randIndex = _.random(3);
			const queenPos = positions[randIndex];
			positions.splice(randIndex, 1);

			randIndex = _.random(2);
			const kingPos = positions[randIndex];
			positions.splice(randIndex, 1);

			randIndex = _.random(1);
			const rookPos = positions[randIndex];
			positions.splice(randIndex, 1);
			const immobilizerPos = positions[0];

			pieces[c][bishop1Pos] = 'b';
			pieces[c][bishop2Pos] = 'b';
			pieces[c][knight1Pos] = 'n';
			pieces[c][knight2Pos] = 'n';
			pieces[c][queenPos] = 'q';
			pieces[c][kingPos] = 'k';
			pieces[c][rookPos] = 'r';
			pieces[c][immobilizerPos] = 'm';
		}
		return pieces["b"].join("") +
			"/pppppppp/8/8/8/8/PPPPPPPP/" +
			pieces["w"].join("").toUpperCase() +
			" 0000"; //TODO: flags?!
	}

	getFlagsFen()
	{
		return "0000"; //TODO: or "-" ?
	}
}
Commit	Line	Data
32cfcea4 BA	1	class UltimaRules extends ChessRules
32cfcea4 BA	2	{
2eef6db6 BA	3	static getPpath(b)
	4	{
	5	if (b[1] == "m") //'m' for Immobilizer (I is too similar to 1)
	6	return "Ultima/" + b;
	7	return b; //usual piece
	8	}
32cfcea4	9
2eef6db6 BA	10	initVariables(fen)
	11	{
	12	this.kingPos = {'w':[-1,-1], 'b':[-1,-1]};
	13	const fenParts = fen.split(" ");
	14	const position = fenParts[0].split("/");
	15	for (let i=0; i<position.length; i++)
	16	{
	17	let k = 0;
	18	for (let j=0; j<position[i].length; j++)
	19	{
	20	switch (position[i].charAt(j))
	21	{
	22	case 'k':
	23	this.kingPos['b'] = [i,k];
	24	break;
	25	case 'K':
	26	this.kingPos['w'] = [i,k];
	27	break;
	28	default:
	29	let num = parseInt(position[i].charAt(j));
	30	if (!isNaN(num))
	31	k += (num-1);
	32	}
	33	k++;
	34	}
	35	}
	36	this.epSquares = []; //no en-passant here
	37	}
	38
	39	setFlags(fen)
	40	{
	41	// TODO: for compatibility?
	42	this.castleFlags = {"w":[false,false], "b":[false,false]};
	43	}
	44
	45	static get IMMOBILIZER() { return 'm'; }
	46	// Although other pieces keep their names here for coding simplicity,
	47	// keep in mind that:
	48	// - a "rook" is a coordinator, capturing by coordinating with the king
	49	// - a "knight" is a long-leaper, capturing as in draughts
	50	// - a "bishop" is a chameleon, capturing as its prey
	51	// - a "queen" is a withdrawer, capturing by moving away from pieces
	52
	53	getPotentialMovesFrom([x,y])
	54	{
7688bf77	55	// Pre-check: is thing on this square immobilized?
7688bf77 BA	56	const piece = this.getPiece(x,y);
	57	const color = this.getColor(x,y);
	58	const oppCol = this.getOppCol(color);
	59	const V = VariantRules;
	60	const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
	61	const [sizeX,sizeY] = V.size;
9d218497	62	outerLoop:
7688bf77 BA	63	for (let step of adjacentSteps)
	64	{
	65	const [i,j] = [x+step[0],y+step[1]];
	66	if (i>=0 && i<sizeX && j>=0 && j<sizeY && this.board[i][j] != V.EMPTY
	67	&& this.getColor(i,j) == oppCol)
	68	{
	69	const oppPiece = this.getPiece(i,j);
9d218497 BA	70	if (oppPiece == V.BISHOP && piece == V.IMMOBILIZER)
	71	return [];
	72	if (oppPiece == V.IMMOBILIZER && ![V.BISHOP,V.IMMOBILIZER].includes(piece))
7688bf77	73	{
9d218497 BA	74	// Moving is impossible only if this immobilizer is not neutralized
	75	for (let step2 of adjacentSteps)
	76	{
	77	const [i2,j2] = [i+step2[0],j+step2[1]];
	78	if (i2>=0 && i2<sizeX && j2>=0 && j2<sizeY
	79	&& this.board[i2][j2] != V.EMPTY && this.getColor(i2,j2) == color)
	80	{
	81	const friendlyPiece = this.getPiece(i2,j2);
	82	if ([V.BISHOP,V.IMMOBILIZER].includes(friendlyPiece))
	83	break outerLoop;
	84	}
	85	}
	86	return []; //immobilizer isn't neutralized
7688bf77 BA	87	}
	88	}
	89	}
2eef6db6 BA	90	switch (this.getPiece(x,y))
	91	{
	92	case VariantRules.IMMOBILIZER:
	93	return this.getPotentialImmobilizerMoves([x,y]);
	94	default:
	95	return super.getPotentialMovesFrom([x,y]);
	96	}
2eef6db6 BA	97	}
	98
	99	getSlideNJumpMoves([x,y], steps, oneStep)
	100	{
	101	const color = this.getColor(x,y);
	102	const piece = this.getPiece(x,y);
	103	let moves = [];
	104	const [sizeX,sizeY] = VariantRules.size;
	105	outerLoop:
	106	for (let step of steps)
	107	{
	108	let i = x + step[0];
	109	let j = y + step[1];
	110	while (i>=0 && i<sizeX && j>=0 && j<sizeY
	111	&& this.board[i][j] == VariantRules.EMPTY)
	112	{
	113	moves.push(this.getBasicMove([x,y], [i,j]));
	114	if (oneStep !== undefined)
	115	continue outerLoop;
	116	i += step[0];
	117	j += step[1];
	118	}
	119	// Only king can take on occupied square:
	120	if (piece==VariantRules.KING && i>=0 && i<sizeX && j>=0
	121	&& j<sizeY && this.canTake([x,y], [i,j]))
	122	{
	123	moves.push(this.getBasicMove([x,y], [i,j]));
	124	}
	125	}
	126	return moves;
	127	}
	128
a3c86ec9 BA	129	// Modify capturing moves among listed pawn moves
	130	addPawnCaptures(moves, byChameleon)
	131	{
	132	const steps = VariantRules.steps[VariantRules.ROOK];
	133	const [sizeX,sizeY] = VariantRules.size;
	134	const color = this.turn;
	135	const oppCol = this.getOppCol(color);
	136	moves.forEach(m => {
	137	if (!!byChameleon && m.start.x!=m.end.x && m.start.y!=m.end.y)
	138	return; //chameleon not moving as pawn
	139	// Try capturing in every direction
	140	for (let step of steps)
	141	{
	142	const sq2 = [m.end.x+2step[0],m.end.y+2step[1]];
	143	if (sq2[0]>=0 && sq2[0]<sizeX && sq2[1]>=0 && sq2[1]<sizeY
	144	&& this.board[sq2[0]][sq2[1]] != VariantRules.EMPTY
	145	&& this.getColor(sq2[0],sq2[1]) == color)
	146	{
	147	// Potential capture
	148	const sq1 = [m.end.x+step[0],m.end.y+step[1]];
	149	if (this.board[sq1[0]][sq1[1]] != VariantRules.EMPTY
	150	&& this.getColor(sq1[0],sq1[1]) == oppCol)
	151	{
	152	const piece1 = this.getPiece(sq1[0],sq1[1]);
	153	if (!byChameleon \|\| piece1 == VariantRules.PAWN)
	154	{
	155	m.vanish.push(new PiPo({
	156	x:sq1[0],
	157	y:sq1[1],
	158	c:oppCol,
	159	p:piece1
	160	}));
	161	}
	162	}
	163	}
	164	}
	165	});
	166	}
	167
7688bf77	168	// "Pincher"
2eef6db6 BA	169	getPotentialPawnMoves([x,y])
2eef6db6 BA	170	{
7688bf77	171	let moves = super.getPotentialRookMoves([x,y]);
a3c86ec9 BA	172	this.addPawnCaptures(moves);
a3c86ec9 BA	173	return moves;
2eef6db6 BA	174	}
2eef6db6 BA	175
a3c86ec9	176	addRookCaptures(moves, byChameleon)
2eef6db6	177	{
a3c86ec9	178	const color = this.turn;
7688bf77 BA	179	const oppCol = this.getOppCol(color);
7688bf77 BA	180	const kp = this.kingPos[color];
7688bf77 BA	181	moves.forEach(m => {
	182	// Check piece-king rectangle (if any) corners for enemy pieces
	183	if (m.end.x == kp[0] \|\| m.end.y == kp[1])
	184	return; //"flat rectangle"
	185	const corner1 = [Math.max(m.end.x,kp[0]), Math.min(m.end.y,kp[1])];
	186	const corner2 = [Math.min(m.end.x,kp[0]), Math.max(m.end.y,kp[1])];
	187	for (let [i,j] of [corner1,corner2])
	188	{
	189	if (this.board[i][j] != VariantRules.EMPTY && this.getColor(i,j) == oppCol)
	190	{
a3c86ec9 BA	191	const piece = this.getPiece(i,j);
	192	if (!byChameleon \|\| piece == VariantRules.ROOK)
	193	{
	194	m.vanish.push( new PiPo({
	195	x:i,
	196	y:j,
	197	p:piece,
	198	c:oppCol
	199	}) );
	200	}
7688bf77 BA	201	}
	202	}
	203	});
a3c86ec9 BA	204	}
	205
	206	// Coordinator
	207	getPotentialRookMoves(sq)
	208	{
	209	let moves = super.getPotentialQueenMoves(sq);
	210	this.addRookCaptures(moves);
7688bf77	211	return moves;
2eef6db6 BA	212	}
2eef6db6 BA	213
7688bf77	214	// Long-leaper
a3c86ec9	215	getKnightCaptures(startSquare, byChameleon)
2eef6db6	216	{
7688bf77 BA	217	// Look in every direction for captures
	218	const V = VariantRules;
	219	const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
	220	const [sizeX,sizeY] = V.size;
a3c86ec9 BA	221	const color = this.turn;
	222	const oppCol = this.getOppCol(color);
	223	let moves = [];
	224	const [x,y] = [startSquare[0],startSquare[1]];
	225	const piece = this.getPiece(x,y); //might be a chameleon!
	226	outerLoop:
7688bf77 BA	227	for (let step of steps)
	228	{
	229	let [i,j] = [x+step[0], y+step[1]];
	230	while (i>=0 && i<sizeX && j>=0 && j<sizeY && this.board[i][j]==V.EMPTY)
	231	{
	232	i += step[0];
	233	j += step[1];
	234	}
a3c86ec9 BA	235	if (i<0 \|\| i>=sizeX \|\| j<0 \|\| j>=sizeY \|\| this.getColor(i,j)==color
	236	\|\| (!!byChameleon && this.getPiece(i,j)!=V.KNIGHT))
	237	{
7688bf77	238	continue;
a3c86ec9 BA	239	}
	240	// last(thing), cur(thing) : stop if "cur" is our color, or beyond board limits,
	241	// or if "last" isn't empty and cur neither. Otherwise, if cur is empty then
	242	// add move until cur square; if cur is occupied then stop if !!byChameleon and
	243	// the square not occupied by a leaper.
	244	let last = [i,j];
	245	let cur = [i+step[0],j+step[1]];
	246	let vanished = [ new PiPo({x:x,y:y,c:color,p:piece}) ];
	247	while (cur[0]>=0 && cur[0]<sizeX && cur[1]>=0 && cur[1]<sizeY)
	248	{
	249	if (this.board[last[0]][last[1]] != V.EMPTY)
	250	{
	251	const oppPiece = this.getPiece(last[0],last[1]);
	252	if (!!byChameleon && oppPiece != V.KNIGHT)
	253	continue outerLoop;
	254	// Something to eat:
	255	vanished.push( new PiPo({x:last[0],y:last[1],c:oppCol,p:oppPiece}) );
	256	}
	257	if (this.board[cur[0]][cur[1]] != V.EMPTY)
	258	{
	259	if (this.getColor(cur[0],cur[1]) == color
	260	\|\| this.board[last[0]][last[1]] != V.EMPTY) //TODO: redundant test
	261	{
	262	continue outerLoop;
	263	}
	264	}
	265	else
	266	{
	267	moves.push(new Move({
	268	appear: [ new PiPo({x:cur[0],y:cur[1],c:color,p:piece}) ],
	269	vanish: JSON.parse(JSON.stringify(vanished)), //TODO: required?
	270	start: {x:x,y:y},
	271	end: {x:cur[0],y:cur[1]}
	272	}));
	273	}
	274	last = [last[0]+step[0],last[1]+step[1]];
	275	cur = [cur[0]+step[0],cur[1]+step[1]];
	276	}
7688bf77 BA	277	}
7688bf77 BA	278	return moves;
2eef6db6 BA	279	}
2eef6db6 BA	280
a3c86ec9 BA	281	// Long-leaper
	282	getPotentialKnightMoves(sq)
	283	{
	284	return super.getPotentialQueenMoves(sq).concat(this.getKnightCaptures(sq));
	285	}
	286
c28265aa	287	getPotentialBishopMoves([x,y])
2eef6db6	288	{
c28265aa BA	289	let moves = super.getPotentialQueenMoves([x,y])
c28265aa BA	290	.concat(this.getKnightCaptures([x,y],"asChameleon"));
a3c86ec9 BA	291	this.addPawnCaptures(moves, "asChameleon");
	292	this.addRookCaptures(moves, "asChameleon");
	293	this.addQueenCaptures(moves, "asChameleon");
c28265aa BA	294	// Add king capture if it's within range
	295	const oppKp = this.kingPos[this.getOppCol(this.turn)];
	296	if (Math.abs(x-oppKp[0]) <= 1 && Math.abs(y-oppKp[1]) <= 1)
	297	moves.push(this.getBasicMove([x,y],oppKp));
a3c86ec9 BA	298	// Post-processing: merge similar moves, concatenating vanish arrays
	299	let mergedMoves = {};
	300	const [sizeX,sizeY] = VariantRules.size;
	301	moves.forEach(m => {
	302	const key = m.end.x + sizeX * m.end.y;
	303	if (!mergedMoves[key])
	304	mergedMoves[key] = m;
	305	else
	306	{
	307	for (let i=1; i<m.vanish.length; i++)
	308	mergedMoves[key].vanish.push(m.vanish[i]);
	309	}
	310	});
	311	// Finally return an array
	312	moves = [];
	313	Object.keys(mergedMoves).forEach(k => { moves.push(mergedMoves[k]); });
	314	return moves;
2eef6db6 BA	315	}
2eef6db6 BA	316
a3c86ec9 BA	317	// Withdrawer
a3c86ec9 BA	318	addQueenCaptures(moves, byChameleon)
2eef6db6	319	{
a3c86ec9 BA	320	if (moves.length == 0)
	321	return;
	322	const [x,y] = [moves[0].start.x,moves[0].start.y];
7688bf77 BA	323	const V = VariantRules;
	324	const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
	325	let capturingDirections = [];
a3c86ec9	326	const color = this.turn;
7688bf77	327	const oppCol = this.getOppCol(color);
a3c86ec9	328	const [sizeX,sizeY] = V.size;
7688bf77 BA	329	adjacentSteps.forEach(step => {
7688bf77 BA	330	const [i,j] = [x+step[0],y+step[1]];
a3c86ec9 BA	331	if (i>=0 && i<sizeX && j>=0 && j<sizeY
	332	&& this.board[i][j] != V.EMPTY && this.getColor(i,j) == oppCol
	333	&& (!byChameleon \|\| this.getPiece(i,j) == V.QUEEN))
	334	{
7688bf77	335	capturingDirections.push(step);
a3c86ec9	336	}
7688bf77 BA	337	});
	338	moves.forEach(m => {
	339	const step = [
	340	m.end.x!=x ? (m.end.x-x)/Math.abs(m.end.x-x) : 0,
	341	m.end.y!=y ? (m.end.y-y)/Math.abs(m.end.y-y) : 0
	342	];
a3c86ec9	343	// NOTE: includes() and even _.isEqual() functions fail...
7688bf77	344	// TODO: this test should be done only once per direction
a3c86ec9 BA	345	if (capturingDirections.some(dir =>
a3c86ec9 BA	346	{ return (dir[0]==-step[0] && dir[1]==-step[1]); }))
7688bf77 BA	347	{
	348	const [i,j] = [x-step[0],y-step[1]];
	349	m.vanish.push(new PiPo({
	350	x:i,
	351	y:j,
	352	p:this.getPiece(i,j),
	353	c:oppCol
	354	}));
	355	}
	356	});
2eef6db6 BA	357	}
2eef6db6 BA	358
a3c86ec9 BA	359	getPotentialQueenMoves(sq)
	360	{
	361	let moves = super.getPotentialQueenMoves(sq);
	362	this.addQueenCaptures(moves);
	363	return moves;
	364	}
	365
45338cdd BA	366	getPotentialImmobilizerMoves(sq)
45338cdd BA	367	{
a3c86ec9	368	// Immobilizer doesn't capture
45338cdd BA	369	return super.getPotentialQueenMoves(sq);
	370	}
	371
2eef6db6 BA	372	getPotentialKingMoves(sq)
	373	{
	374	const V = VariantRules;
	375	return this.getSlideNJumpMoves(sq,
	376	V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
	377	}
	378
9d218497 BA	379	atLeastOneMove()
	380	{
	381	if (this.kingPos[this.turn][0] < 0)
	382	return false;
	383	return super.atLeastOneMove();
	384	}
	385
c28265aa	386	underCheck(move)
2eef6db6	387	{
c28265aa	388	return false; //there is no check
2eef6db6 BA	389	}
2eef6db6 BA	390
c28265aa	391	getCheckSquares(move)
2eef6db6	392	{
c28265aa BA	393	const c = this.getOppCol(this.turn); //opponent
	394	const saveKingPos = this.kingPos[c]; //king might be taken
	395	this.play(move);
	396	// The only way to be "under check" is to have lost the king (thus game over)
	397	let res = this.kingPos[c][0] < 0
	398	? [ JSON.parse(JSON.stringify(saveKingPos)) ]
	399	: [ ];
	400	this.undo(move);
	401	return res;
2eef6db6 BA	402	}
2eef6db6 BA	403
c28265aa	404	updateVariables(move)
2eef6db6	405	{
c28265aa BA	406	// Just update king(s) position(s)
	407	const piece = this.getPiece(move.start.x,move.start.y);
	408	const c = this.getColor(move.start.x,move.start.y);
	409	if (piece == VariantRules.KING && move.appear.length > 0)
7aea7942	410	{
c28265aa BA	411	this.kingPos[c][0] = move.appear[0].x;
	412	this.kingPos[c][1] = move.appear[0].y;
	413	}
	414	// Does this move takes opponent's king?
	415	const oppCol = this.getOppCol(c);
96f8422e	416	for (let i=1; i<move.vanish.length; i++)
c28265aa	417	{
96f8422e	418	if (move.vanish[i].p == VariantRules.KING)
7aea7942	419	{
c28265aa BA	420	this.kingPos[oppCol] = [-1,-1];
c28265aa BA	421	break;
7aea7942 BA	422	}
7aea7942 BA	423	}
2eef6db6 BA	424	}
2eef6db6 BA	425
c28265aa	426	unupdateVariables(move)
2eef6db6	427	{
c28265aa BA	428	super.unupdateVariables(move);
	429	const c = this.getColor(move.start.x,move.start.y);
	430	const oppCol = this.getOppCol(c);
	431	if (this.kingPos[oppCol][0] < 0)
7aea7942	432	{
c28265aa	433	// Last move took opponent's king
96f8422e	434	for (let i=1; i<move.vanish.length; i++)
7aea7942	435	{
96f8422e	436	const psq = move.vanish[i];
c28265aa	437	if (psq.p == 'k')
7aea7942	438	{
c28265aa BA	439	this.kingPos[oppCol] = [psq.x, psq.y];
c28265aa BA	440	break;
7aea7942 BA	441	}
	442	}
	443	}
2eef6db6 BA	444	}
2eef6db6 BA	445
a3c86ec9 BA	446	checkGameEnd()
a3c86ec9 BA	447	{
0279ac93	448	// Stalemate, or our king disappeared
a3c86ec9 BA	449	return this.turn == "w" ? "0-1" : "1-0";
	450	}
	451
2eef6db6 BA	452	static get VALUES() { //TODO: totally experimental!
	453	return {
	454	'p': 1,
	455	'r': 2,
	456	'n': 5,
	457	'b': 3,
	458	'q': 3,
	459	'm': 5,
	460	'k': 1000
	461	};
	462	}
	463
	464	static get SEARCH_DEPTH() { return 2; } //TODO?
	465
c28265aa BA	466	static get THRESHOLD_MATE() {
	467	return 500; //checkmates evals may be slightly below 1000
	468	}
	469
2eef6db6 BA	470	static GenRandInitFen()
	471	{
	472	let pieces = { "w": new Array(8), "b": new Array(8) };
	473	// Shuffle pieces on first and last rank
	474	for (let c of ["w","b"])
	475	{
	476	let positions = _.range(8);
	477	// Get random squares for every piece, totally freely
	478
	479	let randIndex = _.random(7);
	480	const bishop1Pos = positions[randIndex];
	481	positions.splice(randIndex, 1);
	482
	483	randIndex = _.random(6);
	484	const bishop2Pos = positions[randIndex];
	485	positions.splice(randIndex, 1);
	486
	487	randIndex = _.random(5);
	488	const knight1Pos = positions[randIndex];
	489	positions.splice(randIndex, 1);
	490
	491	randIndex = _.random(4);
	492	const knight2Pos = positions[randIndex];
	493	positions.splice(randIndex, 1);
	494
	495	randIndex = _.random(3);
	496	const queenPos = positions[randIndex];
	497	positions.splice(randIndex, 1);
	498
	499	randIndex = _.random(2);
	500	const kingPos = positions[randIndex];
	501	positions.splice(randIndex, 1);
	502
	503	randIndex = _.random(1);
	504	const rookPos = positions[randIndex];
	505	positions.splice(randIndex, 1);
45338cdd	506	const immobilizerPos = positions[0];
2eef6db6 BA	507
	508	pieces[c][bishop1Pos] = 'b';
	509	pieces[c][bishop2Pos] = 'b';
	510	pieces[c][knight1Pos] = 'n';
	511	pieces[c][knight2Pos] = 'n';
	512	pieces[c][queenPos] = 'q';
	513	pieces[c][kingPos] = 'k';
	514	pieces[c][rookPos] = 'r';
	515	pieces[c][immobilizerPos] = 'm';
	516	}
	517	return pieces["b"].join("") +
	518	"/pppppppp/8/8/8/8/PPPPPPPP/" +
	519	pieces["w"].join("").toUpperCase() +
	520	" 0000"; //TODO: flags?!
	521	}
	522
	523	getFlagsFen()
	524	{
	525	return "0000"; //TODO: or "-" ?
	526	}
32cfcea4	527	}