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

//https://www.chessvariants.com/large.dir/freeling.html
class GrandRules extends ChessRules
{
	static getPpath(b)
	{
		const V = VariantRules;
		return ([V.MARSHALL,V.CARDINAL].includes(b[1]) ? "Grand/" : "") + b;
	}

	initVariables(fen)
	{
		super.initVariables(fen);
		this.captures = { "w": {}, "b": {} }; //for promotions
	}

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

	static get MARSHALL() { return 'm'; } //rook+knight
	static get CARDINAL() { return 'c'; } //bishop+knight

	// 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.MARSHALL:
				return this.getPotentialMarshallMoves([x,y]);
			case VariantRules.CARDINAL:
				return this.getPotentialCardinalMoves([x,y]);
			default:
				return super.getPotentialMovesFrom([x,y])
		}
	}

	// Special pawn rules: promotions to captured friendly pieces,
	// optional on ranks 8-9 and mandatory on rank 10.
	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" ? [sizeY-2,sizeY-3] : [1,2]);
		const lastRanks = (color == "w" ? [0,1,2] : [sizeY-1,sizeY-2,sizeY-3]);

		if (x+shift >= 0 && x+shift < sizeX && x+shift != lastRanks[0])
		{
			// 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+2*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 (lastRanks.includes(x+shift))
		{
			// Promotion
			let promotionPieces = [V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN];
			promotionPieces.forEach(p => {
				if (!this.captures[color][p] || this.captures[color][p]==0)
					return;
				// 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;
	}

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

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

	isAttacked(sq, colors)
	{
		return super.isAttacked(sq, colors)
			|| this.isAttackedByMarshall(sq, colors)
			|| this.isAttackedByCardinal(sq, colors);
	}

	isAttackedByMarshall(sq, colors)
	{
		const V = VariantRules;
		return this.isAttackedBySlideNJump(sq, colors, V.MARSHALL, V.steps[V.ROOK])
			|| this.isAttackedBySlideNJump(sq, colors, V.MARSHALL, V.steps[V.KNIGHT], "oneStep");
	}

	isAttackedByCardinal(sq, colors)
	{
		const V = VariantRules;
		return this.isAttackedBySlideNJump(sq, colors, V.CARDINAL, V.steps[V.BISHOP])
			|| this.isAttackedBySlideNJump(sq, colors, V.CARDINAL, V.steps[V.KNIGHT], "oneStep");
	}

	play(move, ingame)
	{
		super.play(move, ingame);
		if (move.vanish.length==2 && move.appear.length==1
			&& move.vanish[1].p != VariantRules.PAWN)
		{
			// Capture: update this.captures
			if (!this.captures[move.vanish[1].c][move.vanish[1].p])
				this.captures[move.vanish[1].c][move.vanish[1].p] = 1;
			else
				this.captures[move.vanish[1].c][move.vanish[1].p]++;
		}
	}

	undo(move)
	{
		super.undo(move);
		if (move.vanish.length==2 && move.appear.length==1
			&& move.vanish[1].p != VariantRules.PAWN)
		{
			// Capture: update this.captures
			this.captures[move.vanish[1].c][move.vanish[1].p] =
				Math.max(0, this.captures[move.vanish[1].c][move.vanish[1].p]-1);
		}
	}

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

	// TODO: this function could be generalized and shared better
	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(10);

			// Get random squares for bishops
			let randIndex = 2 * _.random(4);
			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(7);
			let knight1Pos = positions[randIndex];
			positions.splice(randIndex, 1);
			randIndex = _.random(6);
			let knight2Pos = positions[randIndex];
			positions.splice(randIndex, 1);

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

			// ...random square for marshall
			randIndex = _.random(4);
			let marshallPos = positions[randIndex];
			positions.splice(randIndex, 1);

			// ...random square for cardinal
			randIndex = _.random(3);
			let cardinalPos = 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][marshallPos] = 'm';
			pieces[c][cardinalPos] = 'c';
			pieces[c][kingPos] = 'k';
			pieces[c][bishop2Pos] = 'b';
			pieces[c][knight2Pos] = 'n';
			pieces[c][rook2Pos] = 'r';
		}
		let fen = pieces[0].join("") +
			"/pppppppppp/10/10/10/10/10/10/PPPPPPPPPP/" +
			pieces[1].join("").toUpperCase() +
			" 1111";
		return fen;
	}
}
Commit	Line	Data
a37076f1 BA	1	//https://www.chessvariants.com/large.dir/freeling.html
	2	class GrandRules extends ChessRules
	3	{
	4	static getPpath(b)
	5	{
	6	const V = VariantRules;
c6052161	7	return ([V.MARSHALL,V.CARDINAL].includes(b[1]) ? "Grand/" : "") + b;
a37076f1 BA	8	}
a37076f1 BA	9
c6052161 BA	10	initVariables(fen)
	11	{
	12	super.initVariables(fen);
	13	this.captures = { "w": {}, "b": {} }; //for promotions
	14	}
	15
	16	static get size() { return [10,10]; }
	17
a37076f1 BA	18	static get MARSHALL() { return 'm'; } //rook+knight
	19	static get CARDINAL() { return 'c'; } //bishop+knight
	20
c6052161	21	// En-passant after 2-sq or 3-sq jumps
a37076f1 BA	22	getEpSquare(move)
	23	{
	24	const [sx,sy,ex] = [move.start.x,move.start.y,move.end.x];
c6052161	25	if (this.getPiece(sx,sy) == VariantRules.PAWN && Math.abs(sx - ex) >= 2)
a37076f1	26	{
c6052161 BA	27	const step = (ex-sx) / Math.abs(ex-sx);
	28	let res = [{
	29	x: sx + step,
a37076f1	30	y: sy
c6052161 BA	31	}];
	32	if (sx + 2*step != ex) //3-squares move
	33	{
	34	res.push({
	35	x: sx + 2*step,
	36	y: sy
	37	});
	38	}
	39	return res;
a37076f1 BA	40	}
	41	return undefined; //default
	42	}
	43
	44	getPotentialMovesFrom([x,y])
	45	{
	46	switch (this.getPiece(x,y))
	47	{
	48	case VariantRules.MARSHALL:
	49	return this.getPotentialMarshallMoves([x,y]);
	50	case VariantRules.CARDINAL:
	51	return this.getPotentialCardinalMoves([x,y]);
	52	default:
	53	return super.getPotentialMovesFrom([x,y])
	54	}
	55	}
	56
c6052161 BA	57	// Special pawn rules: promotions to captured friendly pieces,
c6052161 BA	58	// optional on ranks 8-9 and mandatory on rank 10.
a37076f1 BA	59	getPotentialPawnMoves([x,y])
a37076f1 BA	60	{
c6052161 BA	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);
	66	const startRanks = (color == "w" ? [sizeY-2,sizeY-3] : [1,2]);
	67	const lastRanks = (color == "w" ? [0,1,2] : [sizeY-1,sizeY-2,sizeY-3]);
	68
	69	if (x+shift >= 0 && x+shift < sizeX && x+shift != lastRanks[0])
	70	{
	71	// Normal moves
	72	if (this.board[x+shift][y] == V.EMPTY)
	73	{
	74	moves.push(this.getBasicMove([x,y], [x+shift,y]));
	75	if (startRanks.includes(x) && this.board[x+2*shift][y] == V.EMPTY)
	76	{
	77	// Two squares jump
	78	moves.push(this.getBasicMove([x,y], [x+2*shift,y]));
	79	if (x == startRanks[0] && this.board[x+2*shift][y] == V.EMPTY)
	80	{
	81	// 3-squares jump
	82	moves.push(this.getBasicMove([x,y], [x+3*shift,y]));
	83	}
	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 (lastRanks.includes(x+shift))
	94	{
	95	// Promotion
	96	let promotionPieces = [V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN];
	97	promotionPieces.forEach(p => {
	98	if (!this.captures[color][p] \|\| this.captures[color][p]==0)
	99	return;
	100	// Normal move
	101	if (this.board[x+shift][y] == V.EMPTY)
	102	moves.push(this.getBasicMove([x,y], [x+shift,y], {c:color,p:p}));
	103	// Captures
	104	if (y>0 && 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	if (y<sizeY-1 && this.canTake([x,y], [x+shift,y+1]) && this.board[x+shift][y+1] != V.EMPTY)
	107	moves.push(this.getBasicMove([x,y], [x+shift,y+1], {c:color,p:p}));
	108	});
	109	}
	110
	111	// En passant
	112	const Lep = this.epSquares.length;
	113	const epSquare = Lep>0 ? this.epSquares[Lep-1] : undefined;
	114	if (!!epSquare)
	115	{
	116	for (let epsq of epSquare)
	117	{
	118	// TODO: some redundant checks
	119	if (epsq.x == x+shift && Math.abs(epsq.y - y) == 1)
	120	{
	121	let epStep = epsq.y - y;
	122	var enpassantMove = this.getBasicMove([x,y], [x+shift,y+epStep]);
	123	enpassantMove.vanish.push({
	124	x: x,
125	y: y+epStep,
126	p: 'p',
127	c: this.getColor(x,y+epStep)
128	});
129	moves.push(enpassantMove);
130	}
131	}
132	}
133
134	return moves;
a37076f1 BA	135	}
	136
	137	getPotentialMarshallMoves(sq)
	138	{
	139	const V = VariantRules;
	140	return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
	141	this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep"));
	142	}
	143
	144	getPotentialCardinalMoves(sq)
	145	{
	146	const V = VariantRules;
	147	return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat(
	148	this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep"));
	149	}
	150
	151	isAttacked(sq, colors)
	152	{
c6052161	153	return super.isAttacked(sq, colors)
a37076f1 BA	154	\|\| this.isAttackedByMarshall(sq, colors)
	155	\|\| this.isAttackedByCardinal(sq, colors);
	156	}
	157
	158	isAttackedByMarshall(sq, colors)
	159	{
	160	const V = VariantRules;
	161	return this.isAttackedBySlideNJump(sq, colors, V.MARSHALL, V.steps[V.ROOK])
	162	\|\| this.isAttackedBySlideNJump(sq, colors, V.MARSHALL, V.steps[V.KNIGHT], "oneStep");
	163	}
	164
	165	isAttackedByCardinal(sq, colors)
	166	{
	167	const V = VariantRules;
	168	return this.isAttackedBySlideNJump(sq, colors, V.CARDINAL, V.steps[V.BISHOP])
	169	\|\| this.isAttackedBySlideNJump(sq, colors, V.CARDINAL, V.steps[V.KNIGHT], "oneStep");
	170	}
	171
c6052161 BA	172	play(move, ingame)
	173	{
	174	super.play(move, ingame);
	175	if (move.vanish.length==2 && move.appear.length==1
	176	&& move.vanish[1].p != VariantRules.PAWN)
	177	{
	178	// Capture: update this.captures
	179	if (!this.captures[move.vanish[1].c][move.vanish[1].p])
	180	this.captures[move.vanish[1].c][move.vanish[1].p] = 1;
	181	else
	182	this.captures[move.vanish[1].c][move.vanish[1].p]++;
	183	}
	184	}
	185
	186	undo(move)
	187	{
	188	super.undo(move);
	189	if (move.vanish.length==2 && move.appear.length==1
	190	&& move.vanish[1].p != VariantRules.PAWN)
	191	{
	192	// Capture: update this.captures
	193	this.captures[move.vanish[1].c][move.vanish[1].p] =
	194	Math.max(0, this.captures[move.vanish[1].c][move.vanish[1].p]-1);
	195	}
	196	}
	197
a37076f1 BA	198	static get VALUES() {
	199	return Object.assign(
	200	ChessRules.VALUES,
	201	{'c': 5, 'm': 7} //experimental
	202	);
	203	}
	204
c6052161	205	// TODO: this function could be generalized and shared better
a37076f1 BA	206	static GenRandInitFen()
a37076f1 BA	207	{
c6052161 BA	208	let pieces = [new Array(10), new Array(10)];
	209	// Shuffle pieces on first and last rank
	210	for (let c = 0; c <= 1; c++)
	211	{
	212	let positions = _.range(10);
	213
	214	// Get random squares for bishops
	215	let randIndex = 2 * _.random(4);
	216	let bishop1Pos = positions[randIndex];
	217	// The second bishop must be on a square of different color
	218	let randIndex_tmp = 2 * _.random(4) + 1;
	219	let bishop2Pos = positions[randIndex_tmp];
	220	// Remove chosen squares
	221	positions.splice(Math.max(randIndex,randIndex_tmp), 1);
	222	positions.splice(Math.min(randIndex,randIndex_tmp), 1);
	223
	224	// Get random squares for knights
	225	randIndex = _.random(7);
	226	let knight1Pos = positions[randIndex];
	227	positions.splice(randIndex, 1);
	228	randIndex = _.random(6);
	229	let knight2Pos = positions[randIndex];
	230	positions.splice(randIndex, 1);
	231
	232	// Get random square for queen
	233	randIndex = _.random(5);
	234	let queenPos = positions[randIndex];
	235	positions.splice(randIndex, 1);
	236
	237	// ...random square for marshall
	238	randIndex = _.random(4);
	239	let marshallPos = positions[randIndex];
	240	positions.splice(randIndex, 1);
	241
	242	// ...random square for cardinal
	243	randIndex = _.random(3);
	244	let cardinalPos = positions[randIndex];
	245	positions.splice(randIndex, 1);
	246
	247	// Rooks and king positions are now fixed, because of the ordering rook-king-rook
	248	let rook1Pos = positions[0];
	249	let kingPos = positions[1];
	250	let rook2Pos = positions[2];
	251
	252	// Finally put the shuffled pieces in the board array
	253	pieces[c][rook1Pos] = 'r';
	254	pieces[c][knight1Pos] = 'n';
	255	pieces[c][bishop1Pos] = 'b';
	256	pieces[c][queenPos] = 'q';
	257	pieces[c][marshallPos] = 'm';
	258	pieces[c][cardinalPos] = 'c';
	259	pieces[c][kingPos] = 'k';
	260	pieces[c][bishop2Pos] = 'b';
	261	pieces[c][knight2Pos] = 'n';
	262	pieces[c][rook2Pos] = 'r';
	263	}
	264	let fen = pieces[0].join("") +
	265	"/pppppppppp/10/10/10/10/10/10/PPPPPPPPPP/" +
	266	pieces[1].join("").toUpperCase() +
	267	" 1111";
	268	return fen;
a37076f1 BA	269	}
a37076f1 BA	270	}