X-Git-Url: https://git.auder.net/assets/icon_close.svg?a=blobdiff_plain;f=public%2Fjavascripts%2Fbase_rules.js;h=42775dab1553cae4d181eb522f28353cada25f1b;hb=efb20746c30ac26f258f9c5de6dfb70b91980de4;hp=0f637c575695d30d3f8b102c37267952922d19c5;hpb=b8121223012a3eb331022adc465bbfb4014363c8;p=vchess.git

diff --git a/public/javascripts/base_rules.js b/public/javascripts/base_rules.js
index 0f637c57..42775dab 100644
--- a/public/javascripts/base_rules.js
+++ b/public/javascripts/base_rules.js
@@ -171,7 +171,6 @@ class ChessRules
 			'r': [ [-1,0],[1,0],[0,-1],[0,1] ],
 			'n': [ [-1,-2],[-1,2],[1,-2],[1,2],[-2,-1],[-2,1],[2,-1],[2,1] ],
 			'b': [ [-1,-1],[-1,1],[1,-1],[1,1] ],
-			'q': [ [-1,0],[1,0],[0,-1],[0,1],[-1,-1],[-1,1],[1,-1],[1,1] ]
 		};
 	}
 
@@ -285,7 +284,7 @@ class ChessRules
 				i += step[0];
 				j += step[1];
 			}
-			if (i>=0 && i<8 && j>=0 && j<8 && this.canTake([x,y], [i,j]))
+			if (i>=0 && i<sizeX && j>=0 && j<sizeY && this.canTake([x,y], [i,j]))
 				moves.push(this.getBasicMove([x,y], [i,j]));
 		}
 		return moves;
@@ -379,21 +378,25 @@ class ChessRules
 	// What are the queen moves from square x,y ?
 	getPotentialQueenMoves(sq)
 	{
-		return this.getSlideNJumpMoves(sq, VariantRules.steps[VariantRules.QUEEN]);
+		const V = VariantRules;
+		return this.getSlideNJumpMoves(sq, V.steps[V.ROOK].concat(V.steps[V.BISHOP]));
 	}
 
 	// What are the king moves from square x,y ?
 	getPotentialKingMoves(sq)
 	{
+		const V = VariantRules;
 		// Initialize with normal moves
-		let moves = this.getSlideNJumpMoves(sq, VariantRules.steps[VariantRules.QUEEN], "oneStep");
+		let moves = this.getSlideNJumpMoves(sq,
+			V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
 		return moves.concat(this.getCastleMoves(sq));
 	}
 
 	getCastleMoves([x,y])
 	{
 		const c = this.getColor(x,y);
-		if (x != (c=="w" ? 7 : 0) || y != this.INIT_COL_KING[c])
+		const [sizeX,sizeY] = VariantRules.size;
+		if (x != (c=="w" ? sizeX-1 : 0) || y != this.INIT_COL_KING[c])
 			return []; //x isn't first rank, or king has moved (shortcut)
 
 		const V = VariantRules;
@@ -402,7 +405,7 @@ class ChessRules
 		const oppCol = this.getOppCol(c);
 		let moves = [];
 		let i = 0;
-		const finalSquares = [ [2,3], [6,5] ]; //king, then rook
+		const finalSquares = [ [2,3], [sizeY-2,sizeY-3] ]; //king, then rook
 		castlingCheck:
 		for (let castleSide=0; castleSide < 2; castleSide++) //large, then small
 		{
@@ -487,8 +490,8 @@ class ChessRules
 	{
 		const color = this.turn;
 		const oppCol = this.getOppCol(color);
-		var potentialMoves = [];
-		let [sizeX,sizeY] = VariantRules.size;
+		let potentialMoves = [];
+		const [sizeX,sizeY] = VariantRules.size;
 		for (var i=0; i<sizeX; i++)
 		{
 			for (var j=0; j<sizeY; j++)
@@ -508,7 +511,7 @@ class ChessRules
 	{
 		const color = this.turn;
 		const oppCol = this.getOppCol(color);
-		let [sizeX,sizeY] = VariantRules.size;
+		const [sizeX,sizeY] = VariantRules.size;
 		for (let i=0; i<sizeX; i++)
 		{
 			for (let j=0; j<sizeY; j++)
@@ -544,14 +547,15 @@ class ChessRules
 	// Is square x,y attacked by pawns of color c ?
 	isAttackedByPawn([x,y], colors)
 	{
+		const [sizeX,sizeY] = VariantRules.size;
 		for (let c of colors)
 		{
 			let pawnShift = (c=="w" ? 1 : -1);
-			if (x+pawnShift>=0 && x+pawnShift<8)
+			if (x+pawnShift>=0 && x+pawnShift<sizeX)
 			{
 				for (let i of [-1,1])
 				{
-					if (y+i>=0 && y+i<8 && this.getPiece(x+pawnShift,y+i)==VariantRules.PAWN
+					if (y+i>=0 && y+i<sizeY && this.getPiece(x+pawnShift,y+i)==VariantRules.PAWN
 						&& this.getColor(x+pawnShift,y+i)==c)
 					{
 						return true;
@@ -586,30 +590,34 @@ class ChessRules
 	// Is square x,y attacked by queens of color c ?
 	isAttackedByQueen(sq, colors)
 	{
-		return this.isAttackedBySlideNJump(sq, colors,
-			VariantRules.QUEEN, VariantRules.steps[VariantRules.QUEEN]);
+		const V = VariantRules;
+		return this.isAttackedBySlideNJump(sq, colors, V.QUEEN,
+			V.steps[V.ROOK].concat(V.steps[V.BISHOP]));
 	}
 
 	// Is square x,y attacked by king of color c ?
 	isAttackedByKing(sq, colors)
 	{
-		return this.isAttackedBySlideNJump(sq, colors,
-			VariantRules.KING, VariantRules.steps[VariantRules.QUEEN], "oneStep");
+		const V = VariantRules;
+		return this.isAttackedBySlideNJump(sq, colors, V.KING,
+			V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
 	}
 
 	// Generic method for non-pawn pieces ("sliding or jumping"): is x,y attacked by piece != color ?
 	isAttackedBySlideNJump([x,y], colors, piece, steps, oneStep)
 	{
+		const [sizeX,sizeY] = VariantRules.size;
 		for (let step of steps)
 		{
 			let rx = x+step[0], ry = y+step[1];
-			while (rx>=0 && rx<8 && ry>=0 && ry<8 && this.board[rx][ry] == VariantRules.EMPTY
-				&& !oneStep)
+			while (rx>=0 && rx<sizeX && ry>=0 && ry<sizeY
+				&& this.board[rx][ry] == VariantRules.EMPTY && !oneStep)
 			{
 				rx += step[0];
 				ry += step[1];
 			}
-			if (rx>=0 && rx<8 && ry>=0 && ry<8 && this.board[rx][ry] != VariantRules.EMPTY
+			if (rx>=0 && rx<sizeX && ry>=0 && ry<sizeY
+				&& this.board[rx][ry] != VariantRules.EMPTY
 				&& this.getPiece(rx,ry) == piece && colors.includes(this.getColor(rx,ry)))
 			{
 				return true;
@@ -662,7 +670,8 @@ class ChessRules
 	{
 		const piece = this.getPiece(move.start.x,move.start.y);
 		const c = this.getColor(move.start.x,move.start.y);
-		const firstRank = (c == "w" ? 7 : 0);
+		const [sizeX,sizeY] = VariantRules.size;
+		const firstRank = (c == "w" ? sizeX-1 : 0);
 
 		// Update king position + flags
 		if (piece == VariantRules.KING && move.appear.length > 0)
@@ -673,7 +682,7 @@ class ChessRules
 			return;
 		}
 		const oppCol = this.getOppCol(c);
-		const oppFirstRank = 7 - firstRank;
+		const oppFirstRank = (sizeX-1) - firstRank;
 		if (move.start.x == firstRank //our rook moves?
 			&& this.INIT_COL_ROOK[c].includes(move.start.y))
 		{
@@ -698,6 +707,10 @@ class ChessRules
 
 	play(move, ingame)
 	{
+		// DEBUG:
+//		if (!this.states) this.states = [];
+//		if (!ingame) this.states.push(JSON.stringify(this.board));
+
 		if (!!ingame)
 			move.notation = this.getNotation(move);
 
@@ -715,6 +728,11 @@ class ChessRules
 		this.moves.pop();
 		this.unupdateVariables(move);
 		this.parseFlags(JSON.parse(move.flags));
+
+		// DEBUG:
+//		let state = this.states.pop();
+//		if (JSON.stringify(this.board) != state)
+//			debugger;
 	}
 
 	//////////////
@@ -776,17 +794,33 @@ class ChessRules
 		};
 	}
 
+	static get INFINITY() {
+		return 9999; //"checkmate" (unreachable eval)
+	}
+
+	static get THRESHOLD_MATE() {
+		// At this value or above, the game is over
+		return VariantRules.INFINITY;
+	}
+
+	static get SEARCH_DEPTH() {
+		return 3; //2 for high branching factor, 4 for small (Loser chess)
+	}
+
 	// Assumption: at least one legal move
-	getComputerMove()
+	getComputerMove(moves1) //moves1 might be precomputed (Magnetic chess)
 	{
+		this.shouldReturn = false;
+		const maxeval = VariantRules.INFINITY;
 		const color = this.turn;
-		let moves1 = this.getAllValidMoves();
+		if (!moves1)
+			moves1 = this.getAllValidMoves();
 
 		// Rank moves using a min-max at depth 2
 		for (let i=0; i<moves1.length; i++)
 		{
-			moves1[i].eval = (color=="w" ? -1 : 1) * 1000; //very low, I'm checkmated
-			let eval2 = (color=="w" ? 1 : -1) * 1000; //initialized with very high (checkmate) value
+			moves1[i].eval = (color=="w" ? -1 : 1) * maxeval; //very low, I'm checkmated
+			let eval2 = (color=="w" ? 1 : -1) * maxeval; //initialized with checkmate value
 			this.play(moves1[i]);
 			// Second half-move:
 			let moves2 = this.getAllValidMoves();
@@ -808,39 +842,54 @@ class ChessRules
 		}
 		moves1.sort( (a,b) => { return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
 
-		// TODO: show current analyzed move for depth 3, allow stopping eval (return moves1[0])
-		for (let i=0; i<moves1.length; i++)
+		let candidates = [0]; //indices of candidates moves
+		for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
+			candidates.push(j);
+		let currentBest = moves1[_.sample(candidates, 1)];
+
+		// Skip depth 3 if we found a checkmate (or if we are checkmated in 1...)
+		if (VariantRules.SEARCH_DEPTH >= 3
+			&& Math.abs(moves1[0].eval) < VariantRules.THRESHOLD_MATE)
 		{
-			this.play(moves1[i]);
-			// 0.1 * oldEval : heuristic to avoid some bad moves (not all...)
-			moves1[i].eval = 0.1*moves1[i].eval + this.alphabeta(2, -1000, 1000);
-			this.undo(moves1[i]);
+			// TODO: show current analyzed move for depth 3, allow stopping eval (return moves1[0])
+			for (let i=0; i<moves1.length; i++)
+			{
+				if (this.shouldReturn)
+					return currentBest; //depth-2, minimum
+				this.play(moves1[i]);
+				// 0.1 * oldEval : heuristic to avoid some bad moves (not all...)
+				moves1[i].eval = 0.1*moves1[i].eval +
+					this.alphabeta(VariantRules.SEARCH_DEPTH-1, -maxeval, maxeval);
+				this.undo(moves1[i]);
+			}
+			moves1.sort( (a,b) => { return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
 		}
-		moves1.sort( (a,b) => { return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
+		else
+			return currentBest;
 
-		let candidates = [0]; //indices of candidates moves
+		candidates = [0];
 		for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
 			candidates.push(j);
-
 //		console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
 		return moves1[_.sample(candidates, 1)];
 	}
 
 	alphabeta(depth, alpha, beta)
   {
+		const maxeval = VariantRules.INFINITY;
 		const color = this.turn;
 		if (!this.atLeastOneMove())
 		{
 			switch (this.checkGameEnd())
 			{
 				case "1/2": return 0;
-				default: return color=="w" ? -1000 : 1000;
+				default: return color=="w" ? -maxeval : maxeval;
 			}
 		}
 		if (depth == 0)
       return this.evalPosition();
 		const moves = this.getAllValidMoves();
-    let v = color=="w" ? -1000 : 1000;
+    let v = color=="w" ? -maxeval : maxeval;
 		if (color == "w")
 		{
 			for (let i=0; i<moves.length; i++)