X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=public%2Fjavascripts%2Fvariants%2FLoser.js;h=dcc5c112e9740083edfc6f61fb3583953320ef23;hb=f6dbe8e31a3260487664f1e0b50710b3f3efaf5f;hp=da4999fe61bfeab78f92f7c49cdedf6a747b1a38;hpb=32cfcea44bf00b0c6c4d172cca715823076ff490;p=vchess.git

diff --git a/public/javascripts/variants/Loser.js b/public/javascripts/variants/Loser.js
index da4999fe..dcc5c112 100644
--- a/public/javascripts/variants/Loser.js
+++ b/public/javascripts/variants/Loser.js
@@ -1,16 +1,6 @@
 class LoserRules extends ChessRules
 {
-	initVariables(fen)
-	{
-		const epSq = this.moves.length > 0 ? this.getEpSquare(this.lastMove) : undefined;
-		this.epSquares = [ epSq ];
-	}
-
-	setFlags(fen)
-	{
-		// No castling, hence no flags; but flags defined for compatibility
-		this.castleFlags = { "w":[false,false], "b":[false,false] };
-	}
+	static get HasFlags() { return false; }
 
 	getPotentialPawnMoves([x,y])
 	{
@@ -18,10 +8,8 @@ class LoserRules extends ChessRules
 
 		// Complete with promotion(s) into king, if possible
 		const color = this.turn;
-		const V = VariantRules;
-		const [sizeX,sizeY] = VariantRules.size;
 		const shift = (color == "w" ? -1 : 1);
-		const lastRank = (color == "w" ? 0 : sizeX-1);
+		const lastRank = (color == "w" ? 0 : V.size.x-1);
 		if (x+shift == lastRank)
 		{
 			// Normal move
@@ -33,7 +21,7 @@ class LoserRules extends ChessRules
 			{
 				moves.push(this.getBasicMove([x,y], [x+shift,y-1], {c:color,p:V.KING}));
 			}
-			if (y<sizeY-1 && this.canTake([x,y], [x+shift,y+1])
+			if (y<V.size.y-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:V.KING}));
@@ -45,7 +33,7 @@ class LoserRules extends ChessRules
 
 	getPotentialKingMoves(sq)
 	{
-		const V = VariantRules;
+		// No castle:
 		return this.getSlideNJumpMoves(sq,
 			V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
 	}
@@ -55,12 +43,11 @@ class LoserRules extends ChessRules
 	{
 		const color = this.turn;
 		const oppCol = this.getOppCol(color);
-		const [sizeX,sizeY] = VariantRules.size;
-		for (let i=0; i<sizeX; i++)
+		for (let i=0; i<V.size.x; i++)
 		{
-			for (let j=0; j<sizeY; j++)
+			for (let j=0; j<V.size.y; j++)
 			{
-				if (this.board[i][j] != VariantRules.EMPTY && this.getColor(i,j) != oppCol)
+				if (this.board[i][j] != V.EMPTY && this.getColor(i,j) != oppCol)
 				{
 					const moves = this.getPotentialMovesFrom([i,j]);
 					if (moves.length > 0)
@@ -88,7 +75,7 @@ class LoserRules extends ChessRules
 		let moves = this.filterValid( this.getPotentialMovesFrom(sq) );
 		// This is called from interface: we need to know if a capture is possible
 		if (this.atLeastOneCapture())
-			moves = VariantRules.KeepCaptures(moves);
+			moves = V.KeepCaptures(moves);
 		return moves;
 	}
 
@@ -96,11 +83,11 @@ class LoserRules extends ChessRules
 	{
 		let moves = super.getAllValidMoves();
 		if (moves.some(m => { return m.vanish.length == 2; }))
-			moves = VariantRules.KeepCaptures(moves);
+			moves = V.KeepCaptures(moves);
 		return moves;
 	}
 
-	underCheck(move)
+	underCheck(color)
 	{
 		return false; //No notion of check
 	}
@@ -110,22 +97,19 @@ class LoserRules extends ChessRules
 		return [];
 	}
 
-	// Unused:
+	// No variables update because no royal king + no castling
 	updateVariables(move) { }
 	unupdateVariables(move) { }
 
-	getFlagsFen()
-	{
-		return "-";
-	}
-
 	checkGameEnd()
 	{
 		// No valid move: you win!
 		return this.turn == "w" ? "1-0" : "0-1";
 	}
 
-	static get VALUES() { //experimental...
+	static get VALUES()
+	{
+		// Experimental...
 		return {
 			'p': 1,
 			'r': 7,
@@ -142,4 +126,62 @@ class LoserRules extends ChessRules
 	{
 		return - super.evalPosition(); //better with less material
 	}
+
+	static GenRandInitFen()
+	{
+		let pieces = { "w": new Array(8), "b": new Array(8) };
+		// Shuffle pieces on first and last rank
+		for (let c of ["w","b"])
+		{
+			let positions = _.range(8);
+
+			// Get random squares for bishops
+			let randIndex = 2 * _.random(3);
+			let bishop1Pos = positions[randIndex];
+			// The second bishop must be on a square of different color
+			let randIndex_tmp = 2 * _.random(3) + 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(5);
+			let knight1Pos = positions[randIndex];
+			positions.splice(randIndex, 1);
+			randIndex = _.random(4);
+			let knight2Pos = positions[randIndex];
+			positions.splice(randIndex, 1);
+
+			// Get random square for queen
+			randIndex = _.random(3);
+			let queenPos = positions[randIndex];
+			positions.splice(randIndex, 1);
+
+			// Random square for king (no castle)
+			randIndex = _.random(2);
+			let kingPos = positions[randIndex];
+			positions.splice(randIndex, 1);
+
+			// Rooks positions are now fixed
+			let rook1Pos = positions[0];
+			let rook2Pos = positions[1];
+
+			// 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][kingPos] = 'k';
+			pieces[c][bishop2Pos] = 'b';
+			pieces[c][knight2Pos] = 'n';
+			pieces[c][rook2Pos] = 'r';
+		}
+		return pieces["b"].join("") +
+			"/pppppppp/8/8/8/8/PPPPPPPP/" +
+			pieces["w"].join("").toUpperCase() +
+			" w -"; //no en-passant
+	}
 }
+
+const VariantRules = LoserRules;