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

// NOTE: alternative implementation, probably cleaner = use only 1 board
class AliceRules extends ChessRules
{
	static get ALICE_PIECES()
	{
		return {
			's': 'p',
			't': 'q',
			'u': 'r',
			'c': 'b',
			'o': 'n',
			'l': 'k',
		};
	}
	static get ALICE_CODES()
	{
		return {
			'p': 's',
			'q': 't',
			'r': 'u',
			'b': 'c',
			'n': 'o',
			'k': 'l',
		};
	}

	static getPpath(b)
	{
		return (Object.keys(this.ALICE_PIECES).includes(b[1]) ? "Alice/" : "") + b;
	}

	static get PIECES() {
		return ChessRules.PIECES.concat(Object.keys(V.ALICE_PIECES));
	}

	initVariables(fen)
	{
		super.initVariables(fen);
		const fenParts = fen.split(" ");
		const position = fenParts[0].split("/");
		if (this.kingPos["w"][0] < 0 || this.kingPos["b"][0] < 0)
		{
			// INIT_COL_XXX won't be used, so no need to set them for Alice kings
			for (let i=0; i<position.length; i++)
			{
				let k = 0; //column index on board
				for (let j=0; j<position[i].length; j++)
				{
					switch (position[i].charAt(j))
					{
						case 'l':
							this.kingPos['b'] = [i,k];
							break;
						case 'L':
							this.kingPos['w'] = [i,k];
							break;
						default:
							let num = parseInt(position[i].charAt(j));
							if (!isNaN(num))
								k += (num-1);
					}
					k++;
				}
			}
		}
	}

	// Return the (standard) color+piece notation at a square for a board
	getSquareOccupation(i, j, mirrorSide)
	{
		const piece = this.getPiece(i,j);
		if (mirrorSide==1 && Object.keys(V.ALICE_CODES).includes(piece))
			return this.board[i][j];
		else if (mirrorSide==2 && Object.keys(V.ALICE_PIECES).includes(piece))
			return this.getColor(i,j) + V.ALICE_PIECES[piece];
		return "";
	}

	// Build board of the given (mirror)side
	getSideBoard(mirrorSide)
	{
		// Build corresponding board from complete board
		let sideBoard = doubleArray(V.size.x, V.size.y, "");
		for (let i=0; i<V.size.x; i++)
		{
			for (let j=0; j<V.size.y; j++)
				sideBoard[i][j] = this.getSquareOccupation(i, j, mirrorSide);
		}
		return sideBoard;
	}

	// NOTE: castle & enPassant https://www.chessvariants.com/other.dir/alice.html
	getPotentialMovesFrom([x,y], sideBoard)
	{
		const pieces = Object.keys(V.ALICE_CODES);
		const codes = Object.keys(V.ALICE_PIECES);
		const mirrorSide = (pieces.includes(this.getPiece(x,y)) ? 1 : 2);

		// Search valid moves on sideBoard
		let saveBoard = this.board;
		this.board = sideBoard || this.getSideBoard(mirrorSide);
		let moves = super.getPotentialMovesFrom([x,y]);
		this.board = saveBoard;

		// Finally filter impossible moves
		let res = moves.filter(m => {
			if (m.appear.length == 2) //castle
			{
				// appear[i] must be an empty square on the other board
				for (let psq of m.appear)
				{
					if (this.getSquareOccupation(psq.x,psq.y,3-mirrorSide) != V.EMPTY)
						return false;
				}
			}
			else if (this.board[m.end.x][m.end.y] != V.EMPTY)
			{
				// Attempt to capture
				const piece = this.getPiece(m.end.x,m.end.y);
				if ((mirrorSide==1 && codes.includes(piece))
					|| (mirrorSide==2 && pieces.includes(piece)))
				{
					return false;
				}
			}
			// If the move is computed on board1, m.appear change for Alice pieces.
			if (mirrorSide==1)
			{
				m.appear.forEach(psq => { //forEach: castling taken into account
					psq.p = V.ALICE_CODES[psq.p]; //goto board2
				});
			}
			else //move on board2: mark vanishing pieces as Alice
			{
				m.vanish.forEach(psq => {
					psq.p = V.ALICE_CODES[psq.p];
				});
			}
			// Fix en-passant captures
			if (m.vanish[0].p == V.PAWN && m.vanish.length == 2
				&& this.board[m.end.x][m.end.y] == V.EMPTY)
			{
				m.vanish[1].c = this.getOppCol(this.getColor(x,y));
				// In the special case of en-passant, if
				//  - board1 takes board2 : vanish[1] --> Alice
				//  - board2 takes board1 : vanish[1] --> normal
				let van = m.vanish[1];
				if (mirrorSide==1 && codes.includes(this.getPiece(van.x,van.y)))
					van.p = V.ALICE_CODES[van.p];
				else if (mirrorSide==2 && pieces.includes(this.getPiece(van.x,van.y)))
					van.p = V.ALICE_PIECES[van.p];
			}
			return true;
		});
		return res;
	}

	filterValid(moves)
	{
		if (moves.length == 0)
			return [];
		let sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
		return moves.filter(m => { return !this.underCheck(m, sideBoard); });
	}

	getAllValidMoves()
	{
		const color = this.turn;
		const oppCol = this.getOppCol(color);
		var potentialMoves = [];
		let 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]));
				}
			}
		}
		return this.filterValid(potentialMoves, sideBoard);
	}

	// Play on sideboards [TODO: only one sideBoard required]
	playSide(move, sideBoard)
	{
		const pieces = Object.keys(V.ALICE_CODES);
		move.vanish.forEach(psq => {
			const mirrorSide = (pieces.includes(psq.p) ? 1 : 2);
			sideBoard[mirrorSide-1][psq.x][psq.y] = V.EMPTY;
		});
		move.appear.forEach(psq => {
			const mirrorSide = (pieces.includes(psq.p) ? 1 : 2);
			const piece = (mirrorSide == 1 ? psq.p : V.ALICE_PIECES[psq.p]);
			sideBoard[mirrorSide-1][psq.x][psq.y] = psq.c + piece;
			if (piece == V.KING)
				this.kingPos[psq.c] = [psq.x,psq.y];
		});
	}

	// Undo on sideboards
	undoSide(move, sideBoard)
	{
		const pieces = Object.keys(V.ALICE_CODES);
		move.appear.forEach(psq => {
			const mirrorSide = (pieces.includes(psq.p) ? 1 : 2);
			sideBoard[mirrorSide-1][psq.x][psq.y] = V.EMPTY;
		});
		move.vanish.forEach(psq => {
			const mirrorSide = (pieces.includes(psq.p) ? 1 : 2);
			const piece = (mirrorSide == 1 ? psq.p : V.ALICE_PIECES[psq.p]);
			sideBoard[mirrorSide-1][psq.x][psq.y] = psq.c + piece;
			if (piece == V.KING)
				this.kingPos[psq.c] = [psq.x,psq.y];
		});
	}

	underCheck(move, sideBoard) //sideBoard arg always provided
	{
		const color = this.turn;
		this.playSide(move, sideBoard); //no need to track flags
		const kp = this.kingPos[color];
		const mirrorSide = (sideBoard[0][kp[0]][kp[1]] != V.EMPTY ? 1 : 2);
		let saveBoard = this.board;
		this.board = sideBoard[mirrorSide-1];
		let res = this.isAttacked(kp, [this.getOppCol(color)]);
		this.board = saveBoard;
		this.undoSide(move, sideBoard);
		return res;
	}

	getCheckSquares(move)
	{
		this.play(move);
		const color = this.turn; //opponent
		const pieces = Object.keys(V.ALICE_CODES);
		const kp = this.kingPos[color];
		const mirrorSide = (pieces.includes(this.getPiece(kp[0],kp[1])) ? 1 : 2);
		let sideBoard = this.getSideBoard(mirrorSide);
		let saveBoard = this.board;
		this.board = sideBoard;
		let res = this.isAttacked(this.kingPos[color], [this.getOppCol(color)])
			? [ JSON.parse(JSON.stringify(this.kingPos[color])) ]
			: [ ];
		this.board = saveBoard;
		this.undo(move);
		return res;
	}

	updateVariables(move)
	{
		super.updateVariables(move); //standard king
		const piece = this.getPiece(move.start.x,move.start.y);
		const c = this.getColor(move.start.x,move.start.y);
		// "l" = Alice king
		if (piece == "l")
		{
			this.kingPos[c][0] = move.appear[0].x;
			this.kingPos[c][1] = move.appear[0].y;
			this.castleFlags[c] = [false,false];
		}
	}

	unupdateVariables(move)
	{
		super.unupdateVariables(move);
		const c = this.getColor(move.start.x,move.start.y);
		if (this.getPiece(move.start.x,move.start.y) == "l")
			this.kingPos[c] = [move.start.x, move.start.y];
	}

	checkGameEnd()
	{
		const pieces = Object.keys(V.ALICE_CODES);
		const color = this.turn;
		const kp = this.kingPos[color];
		const mirrorSide = (pieces.includes(this.getPiece(kp[0],kp[1])) ? 1 : 2);
		let sideBoard = this.getSideBoard(mirrorSide);
		let saveBoard = this.board;
		this.board = sideBoard;
		let res = "*";
		if (!this.isAttacked(this.kingPos[color], [this.getOppCol(color)]))
			res = "1/2";
		else
			res = (color == "w" ? "0-1" : "1-0");
		this.board = saveBoard;
		return res;
	}

	static get VALUES() {
		return Object.assign(
			ChessRules.VALUES,
			{
				's': 1,
				'u': 5,
				'o': 3,
				'c': 3,
				't': 9,
				'l': 1000,
			}
		);
	}

	getNotation(move)
	{
		if (move.appear.length == 2 && move.appear[0].p == V.KING)
		{
			if (move.end.y < move.start.y)
				return "0-0-0";
			else
				return "0-0";
		}

		const finalSquare = String.fromCharCode(97 + move.end.y) + (V.size.x-move.end.x);
		const piece = this.getPiece(move.start.x, move.start.y);

		const captureMark = (move.vanish.length > move.appear.length ? "x" : "");
		let pawnMark = "";
		if (["p","s"].includes(piece) && captureMark.length == 1)
			pawnMark = String.fromCharCode(97 + move.start.y); //start column

		// Piece or pawn movement
		let notation = piece.toUpperCase() + pawnMark + captureMark + finalSquare;
		if (['s','p'].includes(piece) && !['s','p'].includes(move.appear[0].p))
		{
			// Promotion
			notation += "=" + move.appear[0].p.toUpperCase();
		}
		return notation;
	}
}
Commit	Line	Data
4b353936	1	// NOTE: alternative implementation, probably cleaner = use only 1 board
270968d6	2	class AliceRules extends ChessRules
5bfb0956	3	{
0cd8f2bd	4	static get ALICE_PIECES()
5bfb0956	5	{
270968d6 BA	6	return {
	7	's': 'p',
	8	't': 'q',
	9	'u': 'r',
	10	'c': 'b',
	11	'o': 'n',
	12	'l': 'k',
	13	};
	14	}
	15	static get ALICE_CODES()
	16	{
	17	return {
	18	'p': 's',
	19	'q': 't',
	20	'r': 'u',
	21	'b': 'c',
	22	'n': 'o',
	23	'k': 'l',
	24	};
5bfb0956	25	}
a3eb4cc5	26
0cd8f2bd BA	27	static getPpath(b)
0cd8f2bd BA	28	{
270968d6	29	return (Object.keys(this.ALICE_PIECES).includes(b[1]) ? "Alice/" : "") + b;
0cd8f2bd BA	30	}
0cd8f2bd BA	31
7931e479 BA	32	static get PIECES() {
	33	return ChessRules.PIECES.concat(Object.keys(V.ALICE_PIECES));
	34	}
	35
0b5fa571 BA	36	initVariables(fen)
	37	{
	38	super.initVariables(fen);
	39	const fenParts = fen.split(" ");
	40	const position = fenParts[0].split("/");
	41	if (this.kingPos["w"][0] < 0 \|\| this.kingPos["b"][0] < 0)
	42	{
	43	// INIT_COL_XXX won't be used, so no need to set them for Alice kings
	44	for (let i=0; i<position.length; i++)
	45	{
	46	let k = 0; //column index on board
	47	for (let j=0; j<position[i].length; j++)
	48	{
	49	switch (position[i].charAt(j))
	50	{
	51	case 'l':
	52	this.kingPos['b'] = [i,k];
	53	break;
	54	case 'L':
	55	this.kingPos['w'] = [i,k];
	56	break;
	57	default:
	58	let num = parseInt(position[i].charAt(j));
	59	if (!isNaN(num))
	60	k += (num-1);
	61	}
	62	k++;
	63	}
	64	}
	65	}
	66	}
	67
364128d9 BA	68	// Return the (standard) color+piece notation at a square for a board
	69	getSquareOccupation(i, j, mirrorSide)
	70	{
	71	const piece = this.getPiece(i,j);
364128d9 BA	72	if (mirrorSide==1 && Object.keys(V.ALICE_CODES).includes(piece))
	73	return this.board[i][j];
	74	else if (mirrorSide==2 && Object.keys(V.ALICE_PIECES).includes(piece))
	75	return this.getColor(i,j) + V.ALICE_PIECES[piece];
	76	return "";
	77	}
	78
b8121223 BA	79	// Build board of the given (mirror)side
b8121223 BA	80	getSideBoard(mirrorSide)
0cd8f2bd	81	{
270968d6	82	// Build corresponding board from complete board
0b7d99ec BA	83	let sideBoard = doubleArray(V.size.x, V.size.y, "");
0b7d99ec BA	84	for (let i=0; i<V.size.x; i++)
0cd8f2bd	85	{
0b7d99ec	86	for (let j=0; j<V.size.y; j++)
364128d9	87	sideBoard[i][j] = this.getSquareOccupation(i, j, mirrorSide);
0cd8f2bd	88	}
270968d6 BA	89	return sideBoard;
270968d6 BA	90	}
0cd8f2bd	91
55eb331d	92	// NOTE: castle & enPassant https://www.chessvariants.com/other.dir/alice.html
b8121223	93	getPotentialMovesFrom([x,y], sideBoard)
270968d6	94	{
0b7d99ec BA	95	const pieces = Object.keys(V.ALICE_CODES);
0b7d99ec BA	96	const codes = Object.keys(V.ALICE_PIECES);
b8121223	97	const mirrorSide = (pieces.includes(this.getPiece(x,y)) ? 1 : 2);
0cd8f2bd	98
270968d6 BA	99	// Search valid moves on sideBoard
270968d6 BA	100	let saveBoard = this.board;
b8121223	101	this.board = sideBoard \|\| this.getSideBoard(mirrorSide);
270968d6	102	let moves = super.getPotentialMovesFrom([x,y]);
0cd8f2bd BA	103	this.board = saveBoard;
	104
	105	// Finally filter impossible moves
b8121223	106	let res = moves.filter(m => {
55eb331d	107	if (m.appear.length == 2) //castle
270968d6	108	{
364128d9 BA	109	// appear[i] must be an empty square on the other board
	110	for (let psq of m.appear)
	111	{
0b7d99ec	112	if (this.getSquareOccupation(psq.x,psq.y,3-mirrorSide) != V.EMPTY)
55eb331d	113	return false;
364128d9	114	}
55eb331d	115	}
0b7d99ec	116	else if (this.board[m.end.x][m.end.y] != V.EMPTY)
55eb331d BA	117	{
55eb331d BA	118	// Attempt to capture
270968d6	119	const piece = this.getPiece(m.end.x,m.end.y);
06ddfe34 BA	120	if ((mirrorSide==1 && codes.includes(piece))
06ddfe34 BA	121	\|\| (mirrorSide==2 && pieces.includes(piece)))
270968d6 BA	122	{
	123	return false;
	124	}
	125	}
f6cc7faf BA	126	// If the move is computed on board1, m.appear change for Alice pieces.
	127	if (mirrorSide==1)
	128	{
	129	m.appear.forEach(psq => { //forEach: castling taken into account
0b7d99ec	130	psq.p = V.ALICE_CODES[psq.p]; //goto board2
f6cc7faf BA	131	});
f6cc7faf BA	132	}
0b5fa571 BA	133	else //move on board2: mark vanishing pieces as Alice
	134	{
	135	m.vanish.forEach(psq => {
0b7d99ec	136	psq.p = V.ALICE_CODES[psq.p];
0b5fa571 BA	137	});
0b5fa571 BA	138	}
9de73b71	139	// Fix en-passant captures
0b7d99ec BA	140	if (m.vanish[0].p == V.PAWN && m.vanish.length == 2
0b7d99ec BA	141	&& this.board[m.end.x][m.end.y] == V.EMPTY)
06ddfe34	142	{
9de73b71	143	m.vanish[1].c = this.getOppCol(this.getColor(x,y));
06ddfe34 BA	144	// In the special case of en-passant, if
	145	// - board1 takes board2 : vanish[1] --> Alice
	146	// - board2 takes board1 : vanish[1] --> normal
	147	let van = m.vanish[1];
	148	if (mirrorSide==1 && codes.includes(this.getPiece(van.x,van.y)))
0b7d99ec	149	van.p = V.ALICE_CODES[van.p];
06ddfe34	150	else if (mirrorSide==2 && pieces.includes(this.getPiece(van.x,van.y)))
0b7d99ec	151	van.p = V.ALICE_PIECES[van.p];
06ddfe34	152	}
270968d6 BA	153	return true;
270968d6 BA	154	});
b8121223 BA	155	return res;
	156	}
	157
4b353936	158	filterValid(moves)
b8121223 BA	159	{
	160	if (moves.length == 0)
	161	return [];
4b353936 BA	162	let sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
4b353936 BA	163	return moves.filter(m => { return !this.underCheck(m, sideBoard); });
0cd8f2bd BA	164	}
0cd8f2bd BA	165
b8121223 BA	166	getAllValidMoves()
	167	{
	168	const color = this.turn;
	169	const oppCol = this.getOppCol(color);
	170	var potentialMoves = [];
b8121223	171	let sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
0b7d99ec	172	for (var i=0; i<V.size.x; i++)
b8121223	173	{
0b7d99ec	174	for (var j=0; j<V.size.y; j++)
b8121223	175	{
0b7d99ec	176	if (this.board[i][j] != V.EMPTY && this.getColor(i,j) == color)
b8121223 BA	177	{
b8121223 BA	178	const mirrorSide =
0b7d99ec	179	Object.keys(V.ALICE_CODES).includes(this.getPiece(i,j))
92342261 BA	180	? 1
92342261 BA	181	: 2;
b8121223 BA	182	Array.prototype.push.apply(potentialMoves,
	183	this.getPotentialMovesFrom([i,j], sideBoard[mirrorSide-1]));
	184	}
	185	}
	186	}
	187	return this.filterValid(potentialMoves, sideBoard);
	188	}
	189
4b353936 BA	190	// Play on sideboards [TODO: only one sideBoard required]
	191	playSide(move, sideBoard)
	192	{
0b7d99ec	193	const pieces = Object.keys(V.ALICE_CODES);
4b353936 BA	194	move.vanish.forEach(psq => {
4b353936 BA	195	const mirrorSide = (pieces.includes(psq.p) ? 1 : 2);
0b7d99ec	196	sideBoard[mirrorSide-1][psq.x][psq.y] = V.EMPTY;
4b353936 BA	197	});
	198	move.appear.forEach(psq => {
	199	const mirrorSide = (pieces.includes(psq.p) ? 1 : 2);
0b7d99ec	200	const piece = (mirrorSide == 1 ? psq.p : V.ALICE_PIECES[psq.p]);
4b353936	201	sideBoard[mirrorSide-1][psq.x][psq.y] = psq.c + piece;
0b7d99ec	202	if (piece == V.KING)
4b353936 BA	203	this.kingPos[psq.c] = [psq.x,psq.y];
	204	});
	205	}
	206
	207	// Undo on sideboards
	208	undoSide(move, sideBoard)
0cd8f2bd	209	{
0b7d99ec	210	const pieces = Object.keys(V.ALICE_CODES);
4b353936 BA	211	move.appear.forEach(psq => {
4b353936 BA	212	const mirrorSide = (pieces.includes(psq.p) ? 1 : 2);
0b7d99ec	213	sideBoard[mirrorSide-1][psq.x][psq.y] = V.EMPTY;
4b353936 BA	214	});
	215	move.vanish.forEach(psq => {
	216	const mirrorSide = (pieces.includes(psq.p) ? 1 : 2);
0b7d99ec	217	const piece = (mirrorSide == 1 ? psq.p : V.ALICE_PIECES[psq.p]);
4b353936	218	sideBoard[mirrorSide-1][psq.x][psq.y] = psq.c + piece;
0b7d99ec	219	if (piece == V.KING)
4b353936 BA	220	this.kingPos[psq.c] = [psq.x,psq.y];
	221	});
	222	}
	223
	224	underCheck(move, sideBoard) //sideBoard arg always provided
	225	{
	226	const color = this.turn;
	227	this.playSide(move, sideBoard); //no need to track flags
b8121223	228	const kp = this.kingPos[color];
0b7d99ec	229	const mirrorSide = (sideBoard[0][kp[0]][kp[1]] != V.EMPTY ? 1 : 2);
270968d6	230	let saveBoard = this.board;
4b353936	231	this.board = sideBoard[mirrorSide-1];
cf130369	232	let res = this.isAttacked(kp, [this.getOppCol(color)]);
270968d6	233	this.board = saveBoard;
4b353936	234	this.undoSide(move, sideBoard);
0cd8f2bd BA	235	return res;
	236	}
	237
270968d6	238	getCheckSquares(move)
0cd8f2bd	239	{
270968d6 BA	240	this.play(move);
270968d6 BA	241	const color = this.turn; //opponent
0b7d99ec	242	const pieces = Object.keys(V.ALICE_CODES);
b8121223 BA	243	const kp = this.kingPos[color];
	244	const mirrorSide = (pieces.includes(this.getPiece(kp[0],kp[1])) ? 1 : 2);
	245	let sideBoard = this.getSideBoard(mirrorSide);
270968d6 BA	246	let saveBoard = this.board;
270968d6 BA	247	this.board = sideBoard;
cf130369	248	let res = this.isAttacked(this.kingPos[color], [this.getOppCol(color)])
270968d6 BA	249	? [ JSON.parse(JSON.stringify(this.kingPos[color])) ]
	250	: [ ];
	251	this.board = saveBoard;
	252	this.undo(move);
	253	return res;
0cd8f2bd	254	}
270968d6	255
0b5fa571 BA	256	updateVariables(move)
	257	{
	258	super.updateVariables(move); //standard king
	259	const piece = this.getPiece(move.start.x,move.start.y);
	260	const c = this.getColor(move.start.x,move.start.y);
	261	// "l" = Alice king
	262	if (piece == "l")
	263	{
	264	this.kingPos[c][0] = move.appear[0].x;
	265	this.kingPos[c][1] = move.appear[0].y;
	266	this.castleFlags[c] = [false,false];
	267	}
	268	}
	269
	270	unupdateVariables(move)
	271	{
	272	super.unupdateVariables(move);
	273	const c = this.getColor(move.start.x,move.start.y);
	274	if (this.getPiece(move.start.x,move.start.y) == "l")
	275	this.kingPos[c] = [move.start.x, move.start.y];
	276	}
	277
0cd8f2bd BA	278	checkGameEnd()
0cd8f2bd BA	279	{
0b7d99ec	280	const pieces = Object.keys(V.ALICE_CODES);
0cd8f2bd	281	const color = this.turn;
b8121223 BA	282	const kp = this.kingPos[color];
	283	const mirrorSide = (pieces.includes(this.getPiece(kp[0],kp[1])) ? 1 : 2);
	284	let sideBoard = this.getSideBoard(mirrorSide);
270968d6 BA	285	let saveBoard = this.board;
	286	this.board = sideBoard;
	287	let res = "*";
cf130369	288	if (!this.isAttacked(this.kingPos[color], [this.getOppCol(color)]))
270968d6 BA	289	res = "1/2";
	290	else
	291	res = (color == "w" ? "0-1" : "1-0");
	292	this.board = saveBoard;
	293	return res;
0cd8f2bd	294	}
9de73b71 BA	295
9de73b71 BA	296	static get VALUES() {
92342261 BA	297	return Object.assign(
	298	ChessRules.VALUES,
	299	{
	300	's': 1,
	301	'u': 5,
	302	'o': 3,
	303	'c': 3,
	304	't': 9,
	305	'l': 1000,
	306	}
	307	);
9de73b71	308	}
0f51ef98 BA	309
	310	getNotation(move)
	311	{
0b7d99ec	312	if (move.appear.length == 2 && move.appear[0].p == V.KING)
0f51ef98 BA	313	{
	314	if (move.end.y < move.start.y)
	315	return "0-0-0";
	316	else
	317	return "0-0";
	318	}
	319
0b7d99ec	320	const finalSquare = String.fromCharCode(97 + move.end.y) + (V.size.x-move.end.x);
0f51ef98 BA	321	const piece = this.getPiece(move.start.x, move.start.y);
	322
	323	const captureMark = (move.vanish.length > move.appear.length ? "x" : "");
	324	let pawnMark = "";
	325	if (["p","s"].includes(piece) && captureMark.length == 1)
	326	pawnMark = String.fromCharCode(97 + move.start.y); //start column
	327
	328	// Piece or pawn movement
	329	let notation = piece.toUpperCase() + pawnMark + captureMark + finalSquare;
	330	if (['s','p'].includes(piece) && !['s','p'].includes(move.appear[0].p))
	331	{
	332	// Promotion
	333	notation += "=" + move.appear[0].p.toUpperCase();
	334	}
	335	return notation;
	336	}
5bfb0956	337	}