X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=public%2Fjavascripts%2Fvariants%2FWildebeest.js;h=dcf2d5829e6160a44ab7d8d3318f8889aa8e7bb3;hb=7931e479adf93c87771ded1892a0873af72ae46d;hp=c557a2e8bfab5502d286424df51d5a21c08b3da5;hpb=dca02599df6394b339fd8adb90dc80d06b6620ee;p=vchess.git

diff --git a/public/javascripts/variants/Wildebeest.js b/public/javascripts/variants/Wildebeest.js
index c557a2e8..dcf2d582 100644
--- a/public/javascripts/variants/Wildebeest.js
+++ b/public/javascripts/variants/Wildebeest.js
@@ -1,17 +1,19 @@
-//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 PIECES() {
+		return ChessRules.PIECES.concat([V.CAMEL,V.WILDEBEEST]);
+	}
+
 	static get steps() {
 		return Object.assign(
 			ChessRules.steps, //add camel moves:
@@ -23,7 +25,7 @@ class WildebeestRules extends ChessRules
 	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)
+		if (this.getPiece(sx,sy) == V.PAWN && Math.abs(sx - ex) >= 2)
 		{
 			const step = (ex-sx) / Math.abs(ex-sx);
 			let res = [{
@@ -46,9 +48,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,8 +62,7 @@ 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" ? [sizeX-2,sizeX-3] : [1,2]);
 		const lastRank = (color == "w" ? 0 : sizeX-1);
@@ -84,10 +85,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 +106,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}));
+				}
 			});
 		}
 
@@ -136,13 +149,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,12 +168,11 @@ class WildebeestRules extends ChessRules
 	isAttackedByCamel(sq, colors)
 	{
 		return this.isAttackedBySlideNJump(sq, colors,
-			VariantRules.CAMEL, VariantRules.steps[VariantRules.CAMEL], "oneStep");
+			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]), "oneStep");
 	}
@@ -182,9 +194,8 @@ 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);
 
@@ -196,11 +207,12 @@ class WildebeestRules extends ChessRules
 			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]];
-			// Remove chosen squares
-			for (let idx of randIndexes.concat(randIndexes_tmp).sort((a,b) => { return b-a; }))
+			for (let idx of randIndexes.concat(randIndexes_tmp)
+				.sort((a,b) => { return b-a; })) //largest indices first
+			{
 				positions.splice(idx, 1);
+			}
 
-			// Get random squares for knights
 			let randIndex = _.random(6);
 			let knight1Pos = positions[randIndex];
 			positions.splice(randIndex, 1);
@@ -208,22 +220,19 @@ class WildebeestRules extends ChessRules
 			let knight2Pos = positions[randIndex];
 			positions.splice(randIndex, 1);
 
-			// Get random square for queen
 			randIndex = _.random(4);
 			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,9 +245,9 @@ class WildebeestRules extends ChessRules
 			pieces[c][knight2Pos] = 'n';
 			pieces[c][rook2Pos] = 'r';
 		}
-		let fen = pieces[0].join("") +
+		let fen = pieces["b"].join("") +
 			"/ppppppppppp/11/11/11/11/11/11/PPPPPPPPPPP/" +
-			pieces[1].join("").toUpperCase() +
+			pieces["w"].join("").toUpperCase() +
 			" 1111";
 		return fen;
 	}