X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=public%2Fjavascripts%2Fvariants%2FWildebeest.js;h=ef3779ad9beee3423ad141b49f4c8b10aad2b047;hb=375ecdd1387e729f85ed114e82253469e4849869;hp=2ecc01be82ced002545094cbfb9cc5b7df4e8a36;hpb=8a196305a09269888497995373658f953b9b5bf8;p=vchess.git

diff --git a/public/javascripts/variants/Wildebeest.js b/public/javascripts/variants/Wildebeest.js
index 2ecc01be..ef3779ad 100644
--- a/public/javascripts/variants/Wildebeest.js
+++ b/public/javascripts/variants/Wildebeest.js
@@ -1,29 +1,61 @@
-//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 size() { return {x:10,y:11}; }
 
 	static get CAMEL() { return 'c'; }
 	static get WILDEBEEST() { return 'w'; }
 
-	static get steps() {
+	static get PIECES()
+	{
+		return ChessRules.PIECES.concat([V.CAMEL,V.WILDEBEEST]);
+	}
+
+	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] ]}
 		);
 	}
 
+	// There may be 2 enPassant squares (if pawn jump 3 squares)
+	getEnpassantFen()
+	{
+		const L = this.epSquares.length;
+		if (!this.epSquares[L-1])
+			return "-"; //no en-passant
+		let res = "";
+		this.epSquares[L-1].forEach(sq => {
+			res += V.CoordsToSquare(sq) + ",";
+		});
+		return res.slice(0,-1); //remove last comma
+	}
+
 	// En-passant after 2-sq or 3-sq jumps
-	getEpSquare(move)
+	getEpSquare(moveOrSquare)
 	{
+		if (!moveOrSquare)
+			return undefined;
+		if (typeof moveOrSquare === "string")
+		{
+			const square = moveOrSquare;
+			if (square == "-")
+				return undefined;
+			let res = [];
+			square.split(",").forEach(sq => {
+				res.push(V.SquareToCoords(sq));
+			});
+			return res;
+		}
+		// Argument is a move:
+		const move = moveOrSquare;
 		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)
+		if (this.getPiece(sx,sy) == V.PAWN && Math.abs(sx - ex) >= 2)
 		{
 			const step = (ex-sx) / Math.abs(ex-sx);
 			let res = [{
@@ -46,9 +78,9 @@ class WildebeestRules extends ChessRules
 	{
 		switch (this.getPiece(x,y))
 		{
-			case VariantRules.CAMEL:
+			case V.CAMEL:
 				return this.getPotentialCamelMoves([x,y]);
-			case VariantRules.WILDEBEEST:
+			case V.WILDEBEEST:
 				return this.getPotentialWildebeestMoves([x,y]);
 			default:
 				return super.getPotentialMovesFrom([x,y])
@@ -60,11 +92,10 @@ class WildebeestRules extends ChessRules
 	{
 		const color = this.turn;
 		let moves = [];
-		const V = VariantRules;
-		const [sizeX,sizeY] = VariantRules.size;
+		const [sizeX,sizeY] = [V.size.x,V.size.y];
 		const shift = (color == "w" ? -1 : 1);
-		const startRanks = (color == "w" ? [sizeY-2,sizeY-3] : [1,2]);
-		const lastRank = (color == "w" ? 0 : sizeY-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)
 		{
@@ -84,10 +115,16 @@ class WildebeestRules extends ChessRules
 				}
 			}
 			// Captures
-			if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY)
+			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)
+			}
+			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)
@@ -99,10 +136,16 @@ class WildebeestRules extends ChessRules
 				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)
+				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)
+				}
+				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}));
+				}
 			});
 		}
 
@@ -116,13 +159,12 @@ class WildebeestRules extends ChessRules
 				// 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]);
+					var enpassantMove = this.getBasicMove([x,y], [x+shift,epsq.y]);
 					enpassantMove.vanish.push({
 						x: x,
-						y: y+epStep,
+						y: epsq.y,
 						p: 'p',
-						c: this.getColor(x,y+epStep)
+						c: this.getColor(x,epsq.y)
 					});
 					moves.push(enpassantMove);
 				}
@@ -136,13 +178,13 @@ class WildebeestRules extends ChessRules
 
 	getPotentialCamelMoves(sq)
 	{
-		return this.getSlideNJumpMoves(sq, VariantRules.steps[VariantRules.CAMEL], "oneStep");
+		return this.getSlideNJumpMoves(sq, V.steps[V.CAMEL], "oneStep");
 	}
 
 	getPotentialWildebeestMoves(sq)
 	{
-		const V = VariantRules;
-		return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
+		return this.getSlideNJumpMoves(
+			sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
 	}
 
 	isAttacked(sq, colors)
@@ -155,14 +197,19 @@ class WildebeestRules extends ChessRules
 	isAttackedByCamel(sq, colors)
 	{
 		return this.isAttackedBySlideNJump(sq, colors,
-			VariantRules.CAMEL, VariantRules.steps[VariantRules.CAMEL]);
+			V.CAMEL, V.steps[V.CAMEL], "oneStep");
 	}
 
 	isAttackedByWildebeest(sq, colors)
 	{
-		const V = VariantRules;
 		return this.isAttackedBySlideNJump(sq, colors, V.WILDEBEEST,
-			V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]));
+			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() {
@@ -176,54 +223,45 @@ class WildebeestRules extends ChessRules
 
 	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 pieces = { "w": new Array(10), "b": new Array(10) };
+		for (let c of ["w","b"])
 		{
 			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);
+			// Get random squares for bishops + camels (different colors)
+			let randIndexes = _.sample(_.range(6), 2).map(i => { return 2*i; });
+			let bishop1Pos = positions[randIndexes[0]];
+			let camel1Pos = positions[randIndexes[1]];
+			// The second bishop (camel) must be on a square of different color
+			let randIndexes_tmp = _.sample(_.range(5), 2).map(i => { return 2*i+1; });
+			let bishop2Pos = positions[randIndexes_tmp[0]];
+			let camel2Pos = positions[randIndexes_tmp[1]];
+			for (let idx of randIndexes.concat(randIndexes_tmp)
+				.sort((a,b) => { return b-a; })) //largest indices first
+			{
+				positions.splice(idx, 1);
+			}
+
+			let randIndex = _.random(6);
 			let knight1Pos = positions[randIndex];
 			positions.splice(randIndex, 1);
-			randIndex = _.random(7);
+			randIndex = _.random(5);
 			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];
+			let queenPos = positions[randIndex];
 			positions.splice(randIndex, 1);
 
-			// ...random square for wildebeest
+			// 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';
@@ -236,10 +274,11 @@ class WildebeestRules extends ChessRules
 			pieces[c][knight2Pos] = 'n';
 			pieces[c][rook2Pos] = 'r';
 		}
-		let fen = pieces[0].join("") +
+		return pieces["b"].join("") +
 			"/ppppppppppp/11/11/11/11/11/11/PPPPPPPPPPP/" +
-			pieces[1].join("").toUpperCase() +
-			" 1111";
-		return fen;
+			pieces["w"].join("").toUpperCase() +
+			" w 1111 -";
 	}
 }
+
+const VariantRules = WildebeestRules;