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

class MarseilleRules extends ChessRules
{
	static IsGoodEnpassant(enpassant)
	{
		if (enpassant != "-")
		{
			const squares = enpassant.split(",");
			if (squares.length > 2)
				return false;
			for (let sq of squares)
			{
				const ep = V.SquareToCoords(sq);
				if (isNaN(ep.x) || !V.OnBoard(ep))
					return false;
			}
		}
		return true;
	}

	getTurnFen()
	{
		if (this.startAtFirstMove && this.moves.length==0)
			return "w";
		return this.turn + this.subTurn;
	}

	// There may be 2 enPassant squares (if 2 pawns jump 2 squares in same turn)
	getEnpassantFen()
	{
		const L = this.epSquares.length;
		if (this.epSquares[L-1].every(epsq => epsq === undefined))
			return "-"; //no en-passant
		let res = "";
		this.epSquares[L-1].forEach(epsq => {
			if (!!epsq)
				res += V.CoordsToSquare(epsq) + ",";
		});
		return res.slice(0,-1); //remove last comma
	}

	setOtherVariables(fen)
	{
		const parsedFen = V.ParseFen(fen);
		this.setFlags(parsedFen.flags);
		if (parsedFen.enpassant == "-")
			this.epSquares = [ [undefined,undefined] ];
		else
		{
			let res = [];
			const squares = parsedFen.enpassant.split(",");
			for (let sq of squares)
				res.push(V.SquareToCoords(sq));
			if (res.length == 1)
				res.push(undefined); //always 2 slots in epSquares[i]
			this.epSquares = [ res ];
		}
		this.scanKingsRooks(fen);
		// Extract subTurn from turn indicator: "w" (first move), or
		// "w1" or "w2" white subturn 1 or 2, and same for black
		const fullTurn = V.ParseFen(fen).turn;
		this.startAtFirstMove = (fullTurn == "w");
		this.turn = fullTurn[0];
		this.subTurn = (fullTurn[1] || 1);
	}

	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

		if (x+shiftX >= 0 && x+shiftX < sizeX) //TODO: always true
		{
			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}));
					}
				}
			}
		}

		// En passant: always OK if subturn 1,
		// OK on subturn 2 only if enPassant was played at subturn 1
		// (and if there are two e.p. squares available).
		const Lep = this.epSquares.length;
		const epSquares = this.epSquares[Lep-1]; //always at least one element
		let epSqs = [];
		epSquares.forEach(sq => {
			if (!!sq)
				epSqs.push(sq);
		});
		if (epSqs.length == 0)
			return moves;
		for (let sq of epSqs)
		{
			if (this.subTurn == 1 || (epSqs.length == 2 &&
				// Was this en-passant capture already played at subturn 1 ?
				this.board[epSqs[0].x][epSqs[0].y] != V.EMPTY))
			{
				if (sq.x == x+shiftX && Math.abs(sq.y - y) == 1)
				{
					let epMove = this.getBasicMove([x,y], [sq.x,sq.y]);
					epMove.vanish.push({
						x: x,
						y: sq.y,
						p: 'p',
						c: this.getColor(x,sq.y)
					});
					moves.push(epMove);
				}
			}
		}

		return moves;
	}

	play(move, ingame)
	{
//		console.log("play " + this.getNotation(move));
//		console.log(this.turn + " "+ this.subTurn);
		if (!!ingame)
			move.notation = [this.getNotation(move), this.getLongNotation(move)];
		move.flags = JSON.stringify(this.aggregateFlags());
		let lastEpsq = this.epSquares[this.epSquares.length-1];
		const epSq = this.getEpSquare(move);
		if (lastEpsq.length == 1)
			lastEpsq.push(epSq);
		else
		{
			// New turn
			let newEpsqs = [epSq];
			if (this.startAtFirstMove && this.moves.length == 0)
				newEpsqs.push(undefined); //at first move, to force length==2 (TODO)
			this.epSquares.push(newEpsqs);
		}
		V.PlayOnBoard(this.board, move);
		if (this.startAtFirstMove && this.moves.length == 0)
			this.turn = "b";
		// Does this move give check on subturn 1? If yes, skip subturn 2
		else if (this.subTurn==1 && this.underCheck(this.getOppCol(this.turn)))
		{
			this.epSquares[this.epSquares.length-1].push(undefined);
			this.turn = this.getOppCol(this.turn);
			move.checkOnSubturn1 = true;
		}
		else
		{
			if (this.subTurn == 2)
				this.turn = this.getOppCol(this.turn);
			this.subTurn = 3 - this.subTurn;
		}
		this.moves.push(move);
		this.updateVariables(move);
		if (!!ingame)
			move.hash = hex_md5(this.getFen());
		//console.log(move.checkOnSubturn1 + " " +this.turn + " "+ this.subTurn);
	}

	undo(move)
	{
		this.disaggregateFlags(JSON.parse(move.flags));
		let lastEpsq = this.epSquares[this.epSquares.length-1];
		if (lastEpsq.length == 2)
		{
			if (!!move.checkOnSubturn1 ||
				(this.startAtFirstMove && this.moves.length == 1))
			{
				this.epSquares.pop(); //remove real + artificial e.p. squares
			}
			else
				lastEpsq.pop();
		}
		else
			this.epSquares.pop();
		V.UndoOnBoard(this.board, move);
		if (this.startAtFirstMove && this.moves.length == 1)
			this.turn = "w";
		else if (move.checkOnSubturn1)
		{
			this.turn = this.getOppCol(this.turn);
			this.subTurn = 1;
		}
		else
		{
			if (this.subTurn == 1)
				this.turn = this.getOppCol(this.turn);
			this.subTurn = 3 - this.subTurn;
		}
		this.moves.pop();
		this.unupdateVariables(move);
//		console.log("UNDO " + this.getNotation(move));
//		console.log(this.turn + " "+ this.subTurn);
	}

	// NOTE:  GenRandInitFen() is OK,
	// since at first move turn indicator is just "w"

	// No alpha-beta here, just adapted min-max at depth 2(+1)
	getComputerMove()
	{
		const maxeval = V.INFINITY;
		const color = this.turn;
		const oppCol = this.getOppCol(this.turn);

		// Search best (half) move for opponent turn
		const getBestMoveEval = () => {
			let moves = this.getAllValidMoves();
			if (moves.length == 0)
			{
				const score = this.checkGameEnd();
				if (score == "1/2")
					return 0;
				return maxeval * (score == "1-0" ? 1 : -1);
			}
			let res = (oppCol == "w" ? -maxeval : maxeval);
			for (let m of moves)
			{
				this.play(m);
				this.turn = color; //very artificial...
				if (!this.atLeastOneMove())
				{
					const score = this.checkGameEnd();
					if (score == "1/2")
						res = (oppCol == "w" ? Math.max(res, 0) : Math.min(res, 0));
					else
					{
						// Found a mate
						this.turn = oppCol;
						this.undo(m);
						return maxeval * (score == "1-0" ? 1 : -1);
					}
				}
				const evalPos = this.evalPosition();
				res = (oppCol == "w" ? Math.max(res, evalPos) : Math.min(res, evalPos));
				this.turn = oppCol;
				this.undo(m);
			}
			return res;
		};

		let moves11 = this.getAllValidMoves();
		let doubleMoves = [];
		// Rank moves using a min-max at depth 2
		for (let i=0; i<moves11.length; i++)
		{
			moves11[i].eval = (color=="w" ? -1 : 1) * maxeval;
			this.play(moves11[i]);
			if (this.turn != color)
			{
				// We gave check with last move: search the best opponent move
				doubleMoves.push({moves:[moves11[i]], eval:getBestMoveEval()});
			}
			else
			{
				let moves12 = this.getAllValidMoves();
				for (let j=0; j<moves12.length; j++)
				{
					this.play(moves12[j]);
					doubleMoves.push({
						moves:[moves11[i],moves12[j]],
						eval:getBestMoveEval()});
					this.undo(moves12[j]);
				}
			}
			this.undo(moves11[i]);
		}

		doubleMoves.sort( (a,b) => {
			return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
		let candidates = [0]; //indices of candidates moves
		for (let i=1;
			i<doubleMoves.length && doubleMoves[i].eval == doubleMoves[0].eval;
			i++)
		{
			candidates.push(i);
		}
		const selected = doubleMoves[_.sample(candidates, 1)].moves;
		if (selected.length == 1)
			return selected[0];
		return selected;
	}
}

const VariantRules = MarseilleRules;
Commit	Line	Data
4f7723a1 BA	1	class MarseilleRules extends ChessRules
4f7723a1 BA	2	{
6e62b1c7 BA	3	static IsGoodEnpassant(enpassant)
	4	{
	5	if (enpassant != "-")
	6	{
	7	const squares = enpassant.split(",");
	8	if (squares.length > 2)
	9	return false;
	10	for (let sq of squares)
	11	{
	12	const ep = V.SquareToCoords(sq);
	13	if (isNaN(ep.x) \|\| !V.OnBoard(ep))
	14	return false;
	15	}
	16	}
	17	return true;
	18	}
	19
	20	getTurnFen()
	21	{
	22	if (this.startAtFirstMove && this.moves.length==0)
	23	return "w";
	24	return this.turn + this.subTurn;
	25	}
	26
	27	// There may be 2 enPassant squares (if 2 pawns jump 2 squares in same turn)
	28	getEnpassantFen()
	29	{
	30	const L = this.epSquares.length;
	31	if (this.epSquares[L-1].every(epsq => epsq === undefined))
	32	return "-"; //no en-passant
	33	let res = "";
	34	this.epSquares[L-1].forEach(epsq => {
	35	if (!!epsq)
	36	res += V.CoordsToSquare(epsq) + ",";
	37	});
	38	return res.slice(0,-1); //remove last comma
	39	}
	40
	41	setOtherVariables(fen)
	42	{
	43	const parsedFen = V.ParseFen(fen);
	44	this.setFlags(parsedFen.flags);
	45	if (parsedFen.enpassant == "-")
	46	this.epSquares = [ [undefined,undefined] ];
	47	else
	48	{
	49	let res = [];
	50	const squares = parsedFen.enpassant.split(",");
	51	for (let sq of squares)
	52	res.push(V.SquareToCoords(sq));
	53	if (res.length == 1)
	54	res.push(undefined); //always 2 slots in epSquares[i]
	55	this.epSquares = [ res ];
	56	}
	57	this.scanKingsRooks(fen);
	58	// Extract subTurn from turn indicator: "w" (first move), or
	59	// "w1" or "w2" white subturn 1 or 2, and same for black
	60	const fullTurn = V.ParseFen(fen).turn;
	61	this.startAtFirstMove = (fullTurn == "w");
	62	this.turn = fullTurn[0];
	63	this.subTurn = (fullTurn[1] \|\| 1);
	64	}
	65
	66	getPotentialPawnMoves([x,y])
67	{
68	const color = this.turn;
69	let moves = [];
70	const [sizeX,sizeY] = [V.size.x,V.size.y];
71	const shiftX = (color == "w" ? -1 : 1);
72	const firstRank = (color == 'w' ? sizeX-1 : 0);
73	const startRank = (color == "w" ? sizeX-2 : 1);
74	const lastRank = (color == "w" ? 0 : sizeX-1);
75	const pawnColor = this.getColor(x,y); //can be different for checkered
76
77	if (x+shiftX >= 0 && x+shiftX < sizeX) //TODO: always true
78	{
79	const finalPieces = x + shiftX == lastRank
80	? [V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN]
81	: [V.PAWN]
82	// One square forward
83	if (this.board[x+shiftX][y] == V.EMPTY)
84	{
85	for (let piece of finalPieces)
86	{
87	moves.push(this.getBasicMove([x,y], [x+shiftX,y],
88	{c:pawnColor,p:piece}));
89	}
90	// Next condition because pawns on 1st rank can generally jump
91	if ([startRank,firstRank].includes(x)
92	&& this.board[x+2*shiftX][y] == V.EMPTY)
93	{
94	// Two squares jump
95	moves.push(this.getBasicMove([x,y], [x+2*shiftX,y]));
96	}
97	}
98	// Captures
99	for (let shiftY of [-1,1])
100	{
101	if (y + shiftY >= 0 && y + shiftY < sizeY
102	&& this.board[x+shiftX][y+shiftY] != V.EMPTY
103	&& this.canTake([x,y], [x+shiftX,y+shiftY]))
104	{
105	for (let piece of finalPieces)
106	{
107	moves.push(this.getBasicMove([x,y], [x+shiftX,y+shiftY],
108	{c:pawnColor,p:piece}));
109	}
110	}
111	}
112	}
113
114	// En passant: always OK if subturn 1,
115	// OK on subturn 2 only if enPassant was played at subturn 1
116	// (and if there are two e.p. squares available).
117	const Lep = this.epSquares.length;
118	const epSquares = this.epSquares[Lep-1]; //always at least one element
119	let epSqs = [];
120	epSquares.forEach(sq => {
121	if (!!sq)
122	epSqs.push(sq);
123	});
124	if (epSqs.length == 0)
125	return moves;
126	for (let sq of epSqs)
127	{
128	if (this.subTurn == 1 \|\| (epSqs.length == 2 &&
129	// Was this en-passant capture already played at subturn 1 ?
130	this.board[epSqs[0].x][epSqs[0].y] != V.EMPTY))
131	{
132	if (sq.x == x+shiftX && Math.abs(sq.y - y) == 1)
133	{
134	let epMove = this.getBasicMove([x,y], [sq.x,sq.y]);
135	epMove.vanish.push({
136	x: x,
137	y: sq.y,
138	p: 'p',
139	c: this.getColor(x,sq.y)
140	});
141	moves.push(epMove);
142	}
143	}
144	}
145
146	return moves;
147	}
148
149	play(move, ingame)
150	{
151	// console.log("play " + this.getNotation(move));
152	// console.log(this.turn + " "+ this.subTurn);
153	if (!!ingame)
154	move.notation = [this.getNotation(move), this.getLongNotation(move)];
155	move.flags = JSON.stringify(this.aggregateFlags());
156	let lastEpsq = this.epSquares[this.epSquares.length-1];
157	const epSq = this.getEpSquare(move);
158	if (lastEpsq.length == 1)
159	lastEpsq.push(epSq);
160	else
161	{
162	// New turn
163	let newEpsqs = [epSq];
164	if (this.startAtFirstMove && this.moves.length == 0)
165	newEpsqs.push(undefined); //at first move, to force length==2 (TODO)
166	this.epSquares.push(newEpsqs);
167	}
168	V.PlayOnBoard(this.board, move);
169	if (this.startAtFirstMove && this.moves.length == 0)
170	this.turn = "b";
171	// Does this move give check on subturn 1? If yes, skip subturn 2
172	else if (this.subTurn==1 && this.underCheck(this.getOppCol(this.turn)))
173	{
174	this.epSquares[this.epSquares.length-1].push(undefined);
175	this.turn = this.getOppCol(this.turn);
176	move.checkOnSubturn1 = true;
177	}
178	else
179	{
180	if (this.subTurn == 2)
181	this.turn = this.getOppCol(this.turn);
182	this.subTurn = 3 - this.subTurn;
183	}
184	this.moves.push(move);
185	this.updateVariables(move);
186	if (!!ingame)
187	move.hash = hex_md5(this.getFen());
188	//console.log(move.checkOnSubturn1 + " " +this.turn + " "+ this.subTurn);
189	}
190
191	undo(move)
192	{
193	this.disaggregateFlags(JSON.parse(move.flags));
194	let lastEpsq = this.epSquares[this.epSquares.length-1];
195	if (lastEpsq.length == 2)
196	{
197	if (!!move.checkOnSubturn1 \|\|
198	(this.startAtFirstMove && this.moves.length == 1))
199	{
200	this.epSquares.pop(); //remove real + artificial e.p. squares
201	}
202	else
203	lastEpsq.pop();
204	}
205	else
206	this.epSquares.pop();
207	V.UndoOnBoard(this.board, move);
208	if (this.startAtFirstMove && this.moves.length == 1)
209	this.turn = "w";
210	else if (move.checkOnSubturn1)
211	{
212	this.turn = this.getOppCol(this.turn);
213	this.subTurn = 1;
214	}
215	else
216	{
217	if (this.subTurn == 1)
218	this.turn = this.getOppCol(this.turn);
219	this.subTurn = 3 - this.subTurn;
220	}
221	this.moves.pop();
222	this.unupdateVariables(move);
223	// console.log("UNDO " + this.getNotation(move));
224	// console.log(this.turn + " "+ this.subTurn);
225	}
226
227	// NOTE: GenRandInitFen() is OK,
228	// since at first move turn indicator is just "w"
229
230	// No alpha-beta here, just adapted min-max at depth 2(+1)
231	getComputerMove()
232	{
233	const maxeval = V.INFINITY;
234	const color = this.turn;
235	const oppCol = this.getOppCol(this.turn);
236
237	// Search best (half) move for opponent turn
238	const getBestMoveEval = () => {
239	let moves = this.getAllValidMoves();
240	if (moves.length == 0)
241	{
242	const score = this.checkGameEnd();
243	if (score == "1/2")
244	return 0;
245	return maxeval * (score == "1-0" ? 1 : -1);
246	}
247	let res = (oppCol == "w" ? -maxeval : maxeval);
248	for (let m of moves)
249	{
250	this.play(m);
251	this.turn = color; //very artificial...
252	if (!this.atLeastOneMove())
253	{
254	const score = this.checkGameEnd();
255	if (score == "1/2")
256	res = (oppCol == "w" ? Math.max(res, 0) : Math.min(res, 0));
257	else
258	{
259	// Found a mate
260	this.turn = oppCol;
261	this.undo(m);
262	return maxeval * (score == "1-0" ? 1 : -1);
263	}
264	}
265	const evalPos = this.evalPosition();
266	res = (oppCol == "w" ? Math.max(res, evalPos) : Math.min(res, evalPos));
267	this.turn = oppCol;
268	this.undo(m);
269	}
270	return res;
271	};
272
273	let moves11 = this.getAllValidMoves();
274	let doubleMoves = [];
275	// Rank moves using a min-max at depth 2
276	for (let i=0; i<moves11.length; i++)
277	{
278	moves11[i].eval = (color=="w" ? -1 : 1) * maxeval;
279	this.play(moves11[i]);
280	if (this.turn != color)
281	{
282	// We gave check with last move: search the best opponent move
283	doubleMoves.push({moves:[moves11[i]], eval:getBestMoveEval()});
284	}
285	else
286	{
287	let moves12 = this.getAllValidMoves();
288	for (let j=0; j<moves12.length; j++)
289	{
290	this.play(moves12[j]);
291	doubleMoves.push({
292	moves:[moves11[i],moves12[j]],
293	eval:getBestMoveEval()});
294	this.undo(moves12[j]);
295	}
296	}
297	this.undo(moves11[i]);
298	}
299
300	doubleMoves.sort( (a,b) => {
301	return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
302	let candidates = [0]; //indices of candidates moves
303	for (let i=1;
304	i<doubleMoves.length && doubleMoves[i].eval == doubleMoves[0].eval;
305	i++)
306	{
307	candidates.push(i);
308	}
309	const selected = doubleMoves[_.sample(candidates, 1)].moves;
310	if (selected.length == 1)
311	return selected[0];
312	return selected;
313	}
4f7723a1 BA	314	}
	315
	316	const VariantRules = MarseilleRules;