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

//https://www.chessvariants.com/large.dir/wildebeest.html
class WildebeestRules extends ChessRules
{
	static getPpath(b)
	{
		const V = VariantRules;
		return ([V.CAMEL,V.WILDEBEEST].includes(b[1]) ? "Wildebeest/" : "") + b;
	}

	static get size() { return [10,11]; }

	static get CAMEL() { return 'c'; }
	static get WILDEBEEST() { return 'w'; }

	static get steps() {
		return Object.assign(
			ChessRules.steps, //add camel moves:
			{'c': [ [-3,-1],[-3,1],[-1,-3],[-1,3],[1,-3],[1,3],[3,-1],[3,1] ]}
		);
	}

	// En-passant after 2-sq or 3-sq jumps
	getEpSquare(move)
	{
		const [sx,sy,ex] = [move.start.x,move.start.y,move.end.x];
		if (this.getPiece(sx,sy) == VariantRules.PAWN && Math.abs(sx - ex) >= 2)
		{
			const step = (ex-sx) / Math.abs(ex-sx);
			let res = [{
				x: sx + step,
				y: sy
			}];
			if (sx + 2*step != ex) //3-squares move
			{
				res.push({
					x: sx + 2*step,
					y: sy
				});
			}
			return res;
		}
		return undefined; //default
	}

	getPotentialMovesFrom([x,y])
	{
		switch (this.getPiece(x,y))
		{
			case VariantRules.CAMEL:
				return this.getPotentialCamelMoves([x,y]);
			case VariantRules.WILDEBEEST:
				return this.getPotentialWildebeestMoves([x,y]);
			default:
				return super.getPotentialMovesFrom([x,y])
		}
	}

	// Pawns jump 2 or 3 squares, and promote to queen or wildebeest
	getPotentialPawnMoves([x,y])
	{
		const color = this.turn;
		let moves = [];
		const V = VariantRules;
		const [sizeX,sizeY] = VariantRules.size;
		const shift = (color == "w" ? -1 : 1);
		const startRanks = (color == "w" ? [sizeX-2,sizeX-3] : [1,2]);
		const lastRank = (color == "w" ? 0 : sizeX-1);

		if (x+shift >= 0 && x+shift < sizeX && x+shift != lastRank)
		{
			// Normal moves
			if (this.board[x+shift][y] == V.EMPTY)
			{
				moves.push(this.getBasicMove([x,y], [x+shift,y]));
				if (startRanks.includes(x) && this.board[x+2*shift][y] == V.EMPTY)
				{
					// Two squares jump
					moves.push(this.getBasicMove([x,y], [x+2*shift,y]));
					if (x == startRanks[0] && this.board[x+3*shift][y] == V.EMPTY)
					{
						// 3-squares jump
						moves.push(this.getBasicMove([x,y], [x+3*shift,y]));
					}
				}
			}
			// Captures
			if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY)
				moves.push(this.getBasicMove([x,y], [x+shift,y-1]));
			if (y<sizeY-1 && this.canTake([x,y], [x+shift,y+1]) && this.board[x+shift][y+1] != V.EMPTY)
				moves.push(this.getBasicMove([x,y], [x+shift,y+1]));
		}

		if (x+shift == lastRank)
		{
			// Promotion
			let promotionPieces = [V.QUEEN,V.WILDEBEEST];
			promotionPieces.forEach(p => {
				// Normal move
				if (this.board[x+shift][y] == V.EMPTY)
					moves.push(this.getBasicMove([x,y], [x+shift,y], {c:color,p:p}));
				// Captures
				if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY)
					moves.push(this.getBasicMove([x,y], [x+shift,y-1], {c:color,p:p}));
				if (y<sizeY-1 && this.canTake([x,y], [x+shift,y+1]) && this.board[x+shift][y+1] != V.EMPTY)
					moves.push(this.getBasicMove([x,y], [x+shift,y+1], {c:color,p:p}));
			});
		}

		// En passant
		const Lep = this.epSquares.length;
		const epSquare = Lep>0 ? this.epSquares[Lep-1] : undefined;
		if (!!epSquare)
		{
			for (let epsq of epSquare)
			{
				// TODO: some redundant checks
				if (epsq.x == x+shift && Math.abs(epsq.y - y) == 1)
				{
					let epStep = epsq.y - y;
					var enpassantMove = this.getBasicMove([x,y], [x+shift,y+epStep]);
					enpassantMove.vanish.push({
						x: x,
						y: y+epStep,
						p: 'p',
						c: this.getColor(x,y+epStep)
					});
					moves.push(enpassantMove);
				}
			}
		}

		return moves;
	}

	// TODO: wildebeest castle

	getPotentialCamelMoves(sq)
	{
		return this.getSlideNJumpMoves(sq, VariantRules.steps[VariantRules.CAMEL], "oneStep");
	}

	getPotentialWildebeestMoves(sq)
	{
		const V = VariantRules;
		return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
	}

	isAttacked(sq, colors)
	{
		return super.isAttacked(sq, colors)
			|| this.isAttackedByCamel(sq, colors)
			|| this.isAttackedByWildebeest(sq, colors);
	}

	isAttackedByCamel(sq, colors)
	{
		return this.isAttackedBySlideNJump(sq, colors,
			VariantRules.CAMEL, VariantRules.steps[VariantRules.CAMEL], "oneStep");
	}

	isAttackedByWildebeest(sq, colors)
	{
		const V = VariantRules;
		return this.isAttackedBySlideNJump(sq, colors, V.WILDEBEEST,
			V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
	}

	checkGameEnd()
	{
		// No valid move: game is lost (stalemate is a win)
		return this.turn == "w" ? "0-1" : "1-0";
	}

	static get VALUES() {
		return Object.assign(
			ChessRules.VALUES,
			{'c': 3, 'w': 7} //experimental
		);
	}

	static get SEARCH_DEPTH() { return 2; }

	static GenRandInitFen()
	{
		let pieces = [new Array(10), new Array(10)];
		// Shuffle pieces on first and last rank
		for (let c = 0; c <= 1; c++)
		{
			let positions = _.range(11);

			// Get random squares for bishops
			let randIndex = 2 * _.random(5);
			let bishop1Pos = positions[randIndex];
			// The second bishop must be on a square of different color
			let randIndex_tmp = 2 * _.random(4) + 1;
			let bishop2Pos = positions[randIndex_tmp];
			// Remove chosen squares
			positions.splice(Math.max(randIndex,randIndex_tmp), 1);
			positions.splice(Math.min(randIndex,randIndex_tmp), 1);

			// Get random squares for knights
			randIndex = _.random(8);
			let knight1Pos = positions[randIndex];
			positions.splice(randIndex, 1);
			randIndex = _.random(7);
			let knight2Pos = positions[randIndex];
			positions.splice(randIndex, 1);

			// Get random square for queen
			randIndex = _.random(6);
			let queenPos = positions[randIndex];
			positions.splice(randIndex, 1);

			// ...random square for camels
			randIndex = _.random(5);
			let camel1Pos = positions[randIndex];
			positions.splice(randIndex, 1);
			randIndex = _.random(4);
			let camel2Pos = positions[randIndex];
			positions.splice(randIndex, 1);

			// ...random square for wildebeest
			randIndex = _.random(3);
			let wildebeestPos = positions[randIndex];
			positions.splice(randIndex, 1);

			// Rooks and king positions are now fixed, because of the ordering rook-king-rook
			let rook1Pos = positions[0];
			let kingPos = positions[1];
			let rook2Pos = positions[2];

			// 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][camel1Pos] = 'c';
			pieces[c][camel2Pos] = 'c';
			pieces[c][wildebeestPos] = 'w';
			pieces[c][kingPos] = 'k';
			pieces[c][bishop2Pos] = 'b';
			pieces[c][knight2Pos] = 'n';
			pieces[c][rook2Pos] = 'r';
		}
		let fen = pieces[0].join("") +
			"/ppppppppppp/11/11/11/11/11/11/PPPPPPPPPPP/" +
			pieces[1].join("").toUpperCase() +
			" 1111";
		return fen;
	}
}
Commit	Line	Data
a37076f1	1	//https://www.chessvariants.com/large.dir/wildebeest.html
8a196305	2	class WildebeestRules extends ChessRules
a37076f1 BA	3	{
	4	static getPpath(b)
	5	{
	6	const V = VariantRules;
	7	return ([V.CAMEL,V.WILDEBEEST].includes(b[1]) ? "Wildebeest/" : "") + b;
	8	}
	9
8a196305 BA	10	static get size() { return [10,11]; }
8a196305 BA	11
a37076f1 BA	12	static get CAMEL() { return 'c'; }
	13	static get WILDEBEEST() { return 'w'; }
	14
	15	static get steps() {
	16	return Object.assign(
	17	ChessRules.steps, //add camel moves:
	18	{'c': [ [-3,-1],[-3,1],[-1,-3],[-1,3],[1,-3],[1,3],[3,-1],[3,1] ]}
	19	);
	20	}
	21
8a196305	22	// En-passant after 2-sq or 3-sq jumps
a37076f1 BA	23	getEpSquare(move)
	24	{
	25	const [sx,sy,ex] = [move.start.x,move.start.y,move.end.x];
8a196305	26	if (this.getPiece(sx,sy) == VariantRules.PAWN && Math.abs(sx - ex) >= 2)
a37076f1	27	{
8a196305 BA	28	const step = (ex-sx) / Math.abs(ex-sx);
	29	let res = [{
	30	x: sx + step,
a37076f1	31	y: sy
8a196305 BA	32	}];
	33	if (sx + 2*step != ex) //3-squares move
	34	{
	35	res.push({
	36	x: sx + 2*step,
	37	y: sy
	38	});
	39	}
	40	return res;
a37076f1 BA	41	}
	42	return undefined; //default
	43	}
	44
	45	getPotentialMovesFrom([x,y])
	46	{
	47	switch (this.getPiece(x,y))
	48	{
	49	case VariantRules.CAMEL:
	50	return this.getPotentialCamelMoves([x,y]);
	51	case VariantRules.WILDEBEEST:
	52	return this.getPotentialWildebeestMoves([x,y]);
	53	default:
	54	return super.getPotentialMovesFrom([x,y])
	55	}
	56	}
	57
8a196305	58	// Pawns jump 2 or 3 squares, and promote to queen or wildebeest
a37076f1 BA	59	getPotentialPawnMoves([x,y])
	60	{
	61	const color = this.turn;
	62	let moves = [];
	63	const V = VariantRules;
	64	const [sizeX,sizeY] = VariantRules.size;
	65	const shift = (color == "w" ? -1 : 1);
cf130369 BA	66	const startRanks = (color == "w" ? [sizeX-2,sizeX-3] : [1,2]);
cf130369 BA	67	const lastRank = (color == "w" ? 0 : sizeX-1);
a37076f1 BA	68
	69	if (x+shift >= 0 && x+shift < sizeX && x+shift != lastRank)
	70	{
	71	// Normal moves
	72	if (this.board[x+shift][y] == V.EMPTY)
	73	{
	74	moves.push(this.getBasicMove([x,y], [x+shift,y]));
8a196305	75	if (startRanks.includes(x) && this.board[x+2*shift][y] == V.EMPTY)
a37076f1 BA	76	{
	77	// Two squares jump
	78	moves.push(this.getBasicMove([x,y], [x+2*shift,y]));
8a196305 BA	79	if (x == startRanks[0] && this.board[x+3*shift][y] == V.EMPTY)
	80	{
	81	// 3-squares jump
	82	moves.push(this.getBasicMove([x,y], [x+3*shift,y]));
	83	}
a37076f1 BA	84	}
	85	}
	86	// Captures
	87	if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY)
	88	moves.push(this.getBasicMove([x,y], [x+shift,y-1]));
	89	if (y<sizeY-1 && this.canTake([x,y], [x+shift,y+1]) && this.board[x+shift][y+1] != V.EMPTY)
	90	moves.push(this.getBasicMove([x,y], [x+shift,y+1]));
	91	}
	92
	93	if (x+shift == lastRank)
	94	{
	95	// Promotion
8a196305	96	let promotionPieces = [V.QUEEN,V.WILDEBEEST];
a37076f1 BA	97	promotionPieces.forEach(p => {
	98	// Normal move
	99	if (this.board[x+shift][y] == V.EMPTY)
	100	moves.push(this.getBasicMove([x,y], [x+shift,y], {c:color,p:p}));
	101	// Captures
	102	if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY)
	103	moves.push(this.getBasicMove([x,y], [x+shift,y-1], {c:color,p:p}));
	104	if (y<sizeY-1 && this.canTake([x,y], [x+shift,y+1]) && this.board[x+shift][y+1] != V.EMPTY)
	105	moves.push(this.getBasicMove([x,y], [x+shift,y+1], {c:color,p:p}));
	106	});
	107	}
	108
	109	// En passant
	110	const Lep = this.epSquares.length;
	111	const epSquare = Lep>0 ? this.epSquares[Lep-1] : undefined;
8a196305	112	if (!!epSquare)
a37076f1	113	{
8a196305 BA	114	for (let epsq of epSquare)
	115	{
	116	// TODO: some redundant checks
	117	if (epsq.x == x+shift && Math.abs(epsq.y - y) == 1)
	118	{
	119	let epStep = epsq.y - y;
	120	var enpassantMove = this.getBasicMove([x,y], [x+shift,y+epStep]);
	121	enpassantMove.vanish.push({
	122	x: x,
	123	y: y+epStep,
	124	p: 'p',
	125	c: this.getColor(x,y+epStep)
	126	});
	127	moves.push(enpassantMove);
	128	}
	129	}
a37076f1 BA	130	}
	131
	132	return moves;
	133	}
	134
8a196305 BA	135	// TODO: wildebeest castle
8a196305 BA	136
a37076f1 BA	137	getPotentialCamelMoves(sq)
	138	{
	139	return this.getSlideNJumpMoves(sq, VariantRules.steps[VariantRules.CAMEL], "oneStep");
	140	}
	141
	142	getPotentialWildebeestMoves(sq)
	143	{
	144	const V = VariantRules;
8a196305	145	return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
a37076f1 BA	146	}
a37076f1 BA	147
a37076f1 BA	148	isAttacked(sq, colors)
a37076f1 BA	149	{
8a196305	150	return super.isAttacked(sq, colors)
a37076f1 BA	151	\|\| this.isAttackedByCamel(sq, colors)
	152	\|\| this.isAttackedByWildebeest(sq, colors);
	153	}
	154
	155	isAttackedByCamel(sq, colors)
	156	{
	157	return this.isAttackedBySlideNJump(sq, colors,
cf130369	158	VariantRules.CAMEL, VariantRules.steps[VariantRules.CAMEL], "oneStep");
a37076f1 BA	159	}
	160
	161	isAttackedByWildebeest(sq, colors)
	162	{
	163	const V = VariantRules;
	164	return this.isAttackedBySlideNJump(sq, colors, V.WILDEBEEST,
cf130369	165	V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
a37076f1 BA	166	}
a37076f1 BA	167
cf130369 BA	168	checkGameEnd()
	169	{
	170	// No valid move: game is lost (stalemate is a win)
	171	return this.turn == "w" ? "0-1" : "1-0";
	172	}
efb20746	173
a37076f1 BA	174	static get VALUES() {
	175	return Object.assign(
	176	ChessRules.VALUES,
	177	{'c': 3, 'w': 7} //experimental
	178	);
	179	}
	180
3c09dc49 BA	181	static get SEARCH_DEPTH() { return 2; }
3c09dc49 BA	182
a37076f1 BA	183	static GenRandInitFen()
a37076f1 BA	184	{
8a196305	185	let pieces = [new Array(10), new Array(10)];
a37076f1 BA	186	// Shuffle pieces on first and last rank
	187	for (let c = 0; c <= 1; c++)
	188	{
8a196305	189	let positions = _.range(11);
a37076f1 BA	190
a37076f1 BA	191	// Get random squares for bishops
8a196305	192	let randIndex = 2 * _.random(5);
a37076f1 BA	193	let bishop1Pos = positions[randIndex];
a37076f1 BA	194	// The second bishop must be on a square of different color
8a196305	195	let randIndex_tmp = 2 * _.random(4) + 1;
a37076f1 BA	196	let bishop2Pos = positions[randIndex_tmp];
	197	// Remove chosen squares
	198	positions.splice(Math.max(randIndex,randIndex_tmp), 1);
	199	positions.splice(Math.min(randIndex,randIndex_tmp), 1);
	200
	201	// Get random squares for knights
8a196305	202	randIndex = _.random(8);
a37076f1 BA	203	let knight1Pos = positions[randIndex];
a37076f1 BA	204	positions.splice(randIndex, 1);
8a196305	205	randIndex = _.random(7);
a37076f1 BA	206	let knight2Pos = positions[randIndex];
	207	positions.splice(randIndex, 1);
	208
	209	// Get random square for queen
8a196305	210	randIndex = _.random(6);
a37076f1 BA	211	let queenPos = positions[randIndex];
	212	positions.splice(randIndex, 1);
	213
8a196305 BA	214	// ...random square for camels
	215	randIndex = _.random(5);
	216	let camel1Pos = positions[randIndex];
	217	positions.splice(randIndex, 1);
	218	randIndex = _.random(4);
	219	let camel2Pos = positions[randIndex];
	220	positions.splice(randIndex, 1);
	221
	222	// ...random square for wildebeest
	223	randIndex = _.random(3);
	224	let wildebeestPos = positions[randIndex];
	225	positions.splice(randIndex, 1);
	226
a37076f1 BA	227	// Rooks and king positions are now fixed, because of the ordering rook-king-rook
	228	let rook1Pos = positions[0];
	229	let kingPos = positions[1];
	230	let rook2Pos = positions[2];
	231
	232	// Finally put the shuffled pieces in the board array
	233	pieces[c][rook1Pos] = 'r';
	234	pieces[c][knight1Pos] = 'n';
	235	pieces[c][bishop1Pos] = 'b';
	236	pieces[c][queenPos] = 'q';
8a196305 BA	237	pieces[c][camel1Pos] = 'c';
	238	pieces[c][camel2Pos] = 'c';
	239	pieces[c][wildebeestPos] = 'w';
a37076f1 BA	240	pieces[c][kingPos] = 'k';
	241	pieces[c][bishop2Pos] = 'b';
	242	pieces[c][knight2Pos] = 'n';
	243	pieces[c][rook2Pos] = 'r';
	244	}
	245	let fen = pieces[0].join("") +
8a196305	246	"/ppppppppppp/11/11/11/11/11/11/PPPPPPPPPPP/" +
a37076f1	247	pieces[1].join("").toUpperCase() +
8a196305	248	" 1111";
a37076f1 BA	249	return fen;
	250	}
	251	}