X-Git-Url: https://git.auder.net/?p=vchess.git;a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FLosers.js;h=d815ee7a501668dc1136c85619ee94df403668be;hp=86b00f902a99cda642cf78a8949a41a0256aa06b;hb=dac395887d96e2d642b209c6db6aaacc3ffacb34;hpb=5fde3a01497262862afc4cb4c9457d4e0ad69a4a

diff --git a/client/src/variants/Losers.js b/client/src/variants/Losers.js
index 86b00f90..d815ee7a 100644
--- a/client/src/variants/Losers.js
+++ b/client/src/variants/Losers.js
@@ -4,106 +4,106 @@ import { randInt } from "@/utils/alea";
 
 export const VariantRules = class LosersRules extends ChessRules
 {
-	static get HasFlags() { return false; }
-
-	getPotentialPawnMoves([x,y])
-	{
-		let moves = super.getPotentialPawnMoves([x,y]);
-
-		// Complete with promotion(s) into king, if possible
-		const color = this.turn;
-		const shift = (color == "w" ? -1 : 1);
-		const lastRank = (color == "w" ? 0 : V.size.x-1);
-		if (x+shift == lastRank)
-		{
-			// Normal move
-			if (this.board[x+shift][y] == V.EMPTY)
-				moves.push(this.getBasicMove([x,y], [x+shift,y], {c:color,p:V.KING}));
-			// Captures
-			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:V.KING}));
-			}
-			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}));
-			}
-		}
-
-		return moves;
-	}
-
-	getPotentialKingMoves(sq)
-	{
-		// No castle:
-		return this.getSlideNJumpMoves(sq,
-			V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
-	}
-
-	// Stop at the first capture found (if any)
-	atLeastOneCapture()
-	{
-		const color = this.turn;
-		const oppCol = V.GetOppCol(color);
-		for (let i=0; i<V.size.x; i++)
-		{
-			for (let j=0; j<V.size.y; j++)
-			{
-				if (this.board[i][j] != V.EMPTY && this.getColor(i,j) != oppCol)
-				{
-					const moves = this.getPotentialMovesFrom([i,j]);
-					if (moves.length > 0)
-					{
-						for (let k=0; k<moves.length; k++)
-						{
-							if (moves[k].vanish.length==2 && this.filterValid([moves[k]]).length > 0)
-								return true;
-						}
-					}
-				}
-			}
-		}
-		return false;
-	}
-
-	// Trim all non-capturing moves
-	static KeepCaptures(moves)
-	{
-		return moves.filter(m => { return m.vanish.length == 2; });
-	}
-
-	getPossibleMovesFrom(sq)
-	{
-		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 = V.KeepCaptures(moves);
-		return moves;
-	}
-
-	getAllValidMoves()
-	{
-		let moves = super.getAllValidMoves();
-		if (moves.some(m => { return m.vanish.length == 2; }))
-			moves = V.KeepCaptures(moves);
-		return moves;
-	}
-
-	underCheck(color)
-	{
-		return false; //No notion of check
-	}
-
-	getCheckSquares(move)
-	{
-		return [];
-	}
-
-	// No variables update because no royal king + no castling
-	updateVariables(move) { }
-	unupdateVariables(move) { }
+  static get HasFlags() { return false; }
+
+  getPotentialPawnMoves([x,y])
+  {
+    let moves = super.getPotentialPawnMoves([x,y]);
+
+    // Complete with promotion(s) into king, if possible
+    const color = this.turn;
+    const shift = (color == "w" ? -1 : 1);
+    const lastRank = (color == "w" ? 0 : V.size.x-1);
+    if (x+shift == lastRank)
+    {
+      // Normal move
+      if (this.board[x+shift][y] == V.EMPTY)
+        moves.push(this.getBasicMove([x,y], [x+shift,y], {c:color,p:V.KING}));
+      // Captures
+      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:V.KING}));
+      }
+      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}));
+      }
+    }
+
+    return moves;
+  }
+
+  getPotentialKingMoves(sq)
+  {
+    // No castle:
+    return this.getSlideNJumpMoves(sq,
+      V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
+  }
+
+  // Stop at the first capture found (if any)
+  atLeastOneCapture()
+  {
+    const color = this.turn;
+    const oppCol = V.GetOppCol(color);
+    for (let i=0; i<V.size.x; i++)
+    {
+      for (let j=0; j<V.size.y; j++)
+      {
+        if (this.board[i][j] != V.EMPTY && this.getColor(i,j) != oppCol)
+        {
+          const moves = this.getPotentialMovesFrom([i,j]);
+          if (moves.length > 0)
+          {
+            for (let k=0; k<moves.length; k++)
+            {
+              if (moves[k].vanish.length==2 && this.filterValid([moves[k]]).length > 0)
+                return true;
+            }
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  // Trim all non-capturing moves
+  static KeepCaptures(moves)
+  {
+    return moves.filter(m => { return m.vanish.length == 2; });
+  }
+
+  getPossibleMovesFrom(sq)
+  {
+    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 = V.KeepCaptures(moves);
+    return moves;
+  }
+
+  getAllValidMoves()
+  {
+    let moves = super.getAllValidMoves();
+    if (moves.some(m => { return m.vanish.length == 2; }))
+      moves = V.KeepCaptures(moves);
+    return moves;
+  }
+
+  underCheck(color)
+  {
+    return false; //No notion of check
+  }
+
+  getCheckSquares(move)
+  {
+    return [];
+  }
+
+  // No variables update because no royal king + no castling
+  updateVariables(move) { }
+  unupdateVariables(move) { }
 
   getCurrentScore()
   {
@@ -111,82 +111,82 @@ export const VariantRules = class LosersRules extends ChessRules
       return "*";
 
     // No valid move: the side who cannot move wins
-		return (this.turn == "w" ? "1-0" : "0-1");
-	}
-
-	static get VALUES()
-	{
-		// Experimental...
-		return {
-			'p': 1,
-			'r': 7,
-			'n': 3,
-			'b': 3,
-			'q': 5,
-			'k': 5
-		};
-	}
-
-	static get SEARCH_DEPTH() { return 4; }
-
-	evalPosition()
-	{
-		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 = ArrayFun.range(8);
-
-			// Get random squares for bishops
-			let randIndex = 2 * randInt(4);
-			let bishop1Pos = positions[randIndex];
-			// The second bishop must be on a square of different color
-			let randIndex_tmp = 2 * randInt(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 = randInt(6);
-			let knight1Pos = positions[randIndex];
-			positions.splice(randIndex, 1);
-			randIndex = randInt(5);
-			let knight2Pos = positions[randIndex];
-			positions.splice(randIndex, 1);
-
-			// Get random square for queen
-			randIndex = randInt(4);
-			let queenPos = positions[randIndex];
-			positions.splice(randIndex, 1);
-
-			// Random square for king (no castle)
-			randIndex = randInt(3);
-			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 0 -"; //en-passant allowed, but no flags
-	}
+    return (this.turn == "w" ? "1-0" : "0-1");
+  }
+
+  static get VALUES()
+  {
+    // Experimental...
+    return {
+      'p': 1,
+      'r': 7,
+      'n': 3,
+      'b': 3,
+      'q': 5,
+      'k': 5
+    };
+  }
+
+  static get SEARCH_DEPTH() { return 4; }
+
+  evalPosition()
+  {
+    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 = ArrayFun.range(8);
+
+      // Get random squares for bishops
+      let randIndex = 2 * randInt(4);
+      let bishop1Pos = positions[randIndex];
+      // The second bishop must be on a square of different color
+      let randIndex_tmp = 2 * randInt(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 = randInt(6);
+      let knight1Pos = positions[randIndex];
+      positions.splice(randIndex, 1);
+      randIndex = randInt(5);
+      let knight2Pos = positions[randIndex];
+      positions.splice(randIndex, 1);
+
+      // Get random square for queen
+      randIndex = randInt(4);
+      let queenPos = positions[randIndex];
+      positions.splice(randIndex, 1);
+
+      // Random square for king (no castle)
+      randIndex = randInt(3);
+      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 0 -"; //en-passant allowed, but no flags
+  }
 }