X-Git-Url: https://git.auder.net/pieces/Checkered/cn.svg?a=blobdiff_plain;f=public%2Fjavascripts%2Fvariants%2FAlice.js;h=761682750c5820316d0668376e3d096d98e570b1;hb=b8121223012a3eb331022adc465bbfb4014363c8;hp=d457f5f5b2afe9933b1efff5e4e539937b7c294e;hpb=0b5fa571c10c5d5befc81b3984ead9b4b1a3e14e;p=vchess.git

diff --git a/public/javascripts/variants/Alice.js b/public/javascripts/variants/Alice.js
index d457f5f5..76168275 100644
--- a/public/javascripts/variants/Alice.js
+++ b/public/javascripts/variants/Alice.js
@@ -60,11 +60,10 @@ class AliceRules extends ChessRules
 		}
 	}
 
-	getBoardOfPiece([x,y])
+	// Build board of the given (mirror)side
+	getSideBoard(mirrorSide)
 	{
 		const V = VariantRules;
-		// Build board where the piece is
-		const mirrorSide = (Object.keys(V.ALICE_CODES).includes(this.getPiece(x,y)) ? 1 : 2);
 		// Build corresponding board from complete board
 		const [sizeX,sizeY] = V.size;
 		let sideBoard = doubleArray(sizeX, sizeY, "");
@@ -82,22 +81,22 @@ class AliceRules extends ChessRules
 		return sideBoard;
 	}
 
-	// TODO: move board building one level up (findAllMoves()) to avoid re-building at every piece...
 	// NOTE: castle & enPassant https://www.chessvariants.com/other.dir/alice.html
 	// --> Should be OK as is.
-	getPotentialMovesFrom([x,y])
+	getPotentialMovesFrom([x,y], sideBoard)
 	{
-		let sideBoard = this.getBoardOfPiece([x,y]);
+		const pieces = Object.keys(VariantRules.ALICE_CODES);
+		const codes = Object.keys(VariantRules.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.board = sideBoard || this.getSideBoard(mirrorSide);
 		let moves = super.getPotentialMovesFrom([x,y]);
 		this.board = saveBoard;
 
 		// Finally filter impossible moves
-		const mirrorSide = (Object.keys(VariantRules.ALICE_CODES).includes(this.getPiece(x,y)) ? 1 : 2);
-		return moves.filter(m => {
+		let res = moves.filter(m => {
 			if (m.appear.length == 2) //castle
 			{
 				// If appear[i] not in vanish array, then must be empty square on other board
@@ -113,8 +112,8 @@ class AliceRules extends ChessRules
 			{
 				// Attempt to capture
 				const piece = this.getPiece(m.end.x,m.end.y);
-				if ((mirrorSide==1 && Object.keys(VariantRules.ALICE_PIECES).includes(piece))
-					|| (mirrorSide==2 && Object.keys(VariantRules.ALICE_CODES).includes(piece)))
+				if ((mirrorSide==1 && codes.includes(piece))
+					|| (mirrorSide==2 && pieces.includes(piece)))
 				{
 					return false;
 				}
@@ -132,17 +131,69 @@ class AliceRules extends ChessRules
 					psq.p = VariantRules.ALICE_CODES[psq.p];
 				});
 			}
+			// Fix en-passant captures
+			if (m.vanish.length == 2 && this.board[m.end.x][m.end.y] == VariantRules.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 = VariantRules.ALICE_CODES[van.p];
+				else if (mirrorSide==2 && pieces.includes(this.getPiece(van.x,van.y)))
+					van.p = VariantRules.ALICE_PIECES[van.p];
+			}
 			return true;
 		});
+		return res;
+	}
+
+	// NOTE: alternative implementation, recompute sideBoard's in this function
+	filterValid(moves, sideBoard)
+	{
+		if (moves.length == 0)
+			return [];
+		const pieces = Object.keys(VariantRules.ALICE_CODES);
+		return moves.filter(m => {
+			// WARNING: for underCheck(), we need the sideBoard of the arrival world !
+			const mirrorSide = (pieces.includes(this.getPiece(m.start.x,m.start.y)) ? 2 : 1);
+			return !this.underCheck(m, !!sideBoard ? sideBoard[mirrorSide-1] : null);
+		});
 	}
 
-	underCheck(move)
+	getAllValidMoves()
+	{
+		const color = this.turn;
+		const oppCol = this.getOppCol(color);
+		var potentialMoves = [];
+		let [sizeX,sizeY] = VariantRules.size;
+		let sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
+		for (var i=0; i<sizeX; i++)
+		{
+			for (var j=0; j<sizeY; j++)
+			{
+				if (this.board[i][j] != VariantRules.EMPTY && this.getColor(i,j) == color)
+				{
+					const mirrorSide =
+						(Object.keys(VariantRules.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);
+	}
+
+	underCheck(move, sideBoard)
 	{
 		const color = this.turn;
 		this.play(move);
-		let sideBoard = this.getBoardOfPiece(this.kingPos[color]);
+		const pieces = Object.keys(VariantRules.ALICE_CODES);
+		const kp = this.kingPos[color];
+		const mirrorSide = (pieces.includes(this.getPiece(kp[0],kp[1])) ? 1 : 2);
 		let saveBoard = this.board;
-		this.board = sideBoard;
+		this.board = sideBoard || this.getSideBoard(mirrorSide);
 		let res = this.isAttacked(this.kingPos[color], this.getOppCol(color));
 		this.board = saveBoard;
 		this.undo(move);
@@ -153,7 +204,10 @@ class AliceRules extends ChessRules
 	{
 		this.play(move);
 		const color = this.turn; //opponent
-		let sideBoard = this.getBoardOfPiece(this.kingPos[color]);
+		const pieces = Object.keys(VariantRules.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))
@@ -186,6 +240,41 @@ class AliceRules extends ChessRules
 			this.kingPos[c] = [move.start.x, move.start.y];
 	}
 
+	checkGameEnd()
+	{
+		const pieces = Object.keys(VariantRules.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 {
+			'p': 1,
+			's': 1,
+			'r': 5,
+			'u': 5,
+			'n': 3,
+			'o': 3,
+			'b': 3,
+			'c': 3,
+			'q': 9,
+			't': 9,
+			'k': 1000,
+			'l': 1000
+		};
+	}
+
 	getNotation(move)
 	{
 		if (move.appear.length == 2 && move.appear[0].p == VariantRules.KING)
@@ -200,9 +289,13 @@ class AliceRules extends ChessRules
 			String.fromCharCode(97 + move.end.y) + (VariantRules.size[0]-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() +
-			(move.vanish.length > move.appear.length ? "x" : "") + finalSquare;
+		let notation = piece.toUpperCase() + pawnMark + captureMark + finalSquare;
 		if (['s','p'].includes(piece) && !['s','p'].includes(move.appear[0].p))
 		{
 			// Promotion
@@ -210,19 +303,4 @@ class AliceRules extends ChessRules
 		}
 		return notation;
 	}
-
-	checkGameEnd()
-	{
-		const color = this.turn;
-		let sideBoard = this.getBoardOfPiece(this.kingPos[color]);
-		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;
-	}
 }