X-Git-Url: https://git.auder.net/?p=vchess.git;a=blobdiff_plain;f=public%2Fjavascripts%2Fbase_rules.js;h=e405cbaa4e595da56210f09a7e0920c27c406be1;hp=8b8165a0685ef5f189cc83a1bc1daa36d42707ee;hb=b6487fb9c41705187cf97215fc9e8f86a59057c7;hpb=26c1e3bd4d3e9fb7c86e25c0f423bea57b977111

diff --git a/public/javascripts/base_rules.js b/public/javascripts/base_rules.js
index 8b8165a0..e405cbaa 100644
--- a/public/javascripts/base_rules.js
+++ b/public/javascripts/base_rules.js
@@ -64,22 +64,19 @@ class ChessRules
 		if (!V.IsGoodPosition(fenParsed.position))
 			return false;
 		// 2) Check turn
-		if (!fenParsed.turn || !["w","b"].includes(fenParsed.turn))
+		if (!fenParsed.turn || !V.IsGoodTurn(fenParsed.turn))
 			return false;
-		// 3) Check flags
+		// 3) Check moves count
+		if (!fenParsed.movesCount || !(parseInt(fenParsed.movesCount) >= 0))
+			return false;
+		// 4) Check flags
 		if (V.HasFlags && (!fenParsed.flags || !V.IsGoodFlags(fenParsed.flags)))
 			return false;
-		// 4) Check enpassant
-		if (V.HasEnpassant)
+		// 5) Check enpassant
+		if (V.HasEnpassant &&
+			(!fenParsed.enpassant || !V.IsGoodEnpassant(fenParsed.enpassant)))
 		{
-			if (!fenParsed.enpassant)
-				return false;
-			if (fenParsed.enpassant != "-")
-			{
-				const ep = V.SquareToCoords(fenParsed.enpassant);
-				if (isNaN(ep.x) || !V.OnBoard(ep))
-					return false;
-			}
+			return false;
 		}
 		return true;
 	}
@@ -113,12 +110,29 @@ class ChessRules
 		return true;
 	}
 
+	// For FEN checking
+	static IsGoodTurn(turn)
+	{
+		return ["w","b"].includes(turn);
+	}
+
 	// For FEN checking
 	static IsGoodFlags(flags)
 	{
 		return !!flags.match(/^[01]{4,4}$/);
 	}
 
+	static IsGoodEnpassant(enpassant)
+	{
+		if (enpassant != "-")
+		{
+			const ep = V.SquareToCoords(fenParsed.enpassant);
+			if (isNaN(ep.x) || !V.OnBoard(ep))
+				return false;
+		}
+		return true;
+	}
+
 	// 3 --> d (column number to letter)
 	static CoordToColumn(colnum)
 	{
@@ -126,9 +140,9 @@ class ChessRules
 	}
 
 	// d --> 3 (column letter to number)
-	static ColumnToCoord(colnum)
+	static ColumnToCoord(column)
 	{
-		return String.fromCharCode(97 + colnum);
+		return column.charCodeAt(0) - 97;
 	}
 
 	// a4 --> {x:3,y:0}
@@ -175,7 +189,8 @@ class ChessRules
 		// 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) == V.PAWN && Math.abs(sx - ex) == 2)
+		// TODO: next conditions are first for Atomic, and third for Checkered
+		if (move.appear.length > 0 && move.appear[0].p == V.PAWN && ["w","b"].includes(move.appear[0].c) && Math.abs(sx - ex) == 2)
 		{
 			return {
 				x: (sx + ex)/2,
@@ -276,8 +291,9 @@ class ChessRules
 		{
 			position: fenParts[0],
 			turn: fenParts[1],
+			movesCount: fenParts[2],
 		};
-		let nextIdx = 2;
+		let nextIdx = 3;
 		if (V.HasFlags)
 			Object.assign(res, {flags: fenParts[nextIdx++]});
 		if (V.HasEnpassant)
@@ -288,7 +304,8 @@ class ChessRules
 	// Return current fen (game state)
 	getFen()
 	{
-		return this.getBaseFen() + " " + this.turn +
+		return this.getBaseFen() + " " +
+			this.getTurnFen() + " " + this.movesCount +
 			(V.HasFlags ? (" " + this.getFlagsFen()) : "") +
 			(V.HasEnpassant ? (" " + this.getEnpassantFen()) : "");
 	}
@@ -326,6 +343,11 @@ class ChessRules
 		return position;
 	}
 
+	getTurnFen()
+	{
+		return this.turn;
+	}
+
 	// Flags part of the FEN string
 	getFlagsFen()
 	{
@@ -384,12 +406,12 @@ class ChessRules
 	// INITIALIZATION
 
 	// Fen string fully describes the game state
-	constructor(fen, moves)
+	constructor(fen)
 	{
-		this.moves = moves;
 		const fenParsed = V.ParseFen(fen);
 		this.board = V.GetBoard(fenParsed.position);
-		this.turn = (fenParsed.turn || "w");
+		this.turn = fenParsed.turn[0]; //[0] to work with MarseilleRules
+		this.movesCount = parseInt(fenParsed.movesCount);
 		this.setOtherVariables(fen);
 	}
 
@@ -481,12 +503,6 @@ class ChessRules
 		return (color=="w" ? "b" : "w");
 	}
 
-	get lastMove()
-	{
-		const L = this.moves.length;
-		return (L>0 ? this.moves[L-1] : null);
-	}
-
 	// Pieces codes (for a clearer code)
 	static get PAWN() { return 'p'; }
 	static get ROOK() { return 'r'; }
@@ -612,7 +628,8 @@ class ChessRules
 		const lastRank = (color == "w" ? 0 : sizeX-1);
 		const pawnColor = this.getColor(x,y); //can be different for checkered
 
-		if (x+shiftX >= 0 && x+shiftX < sizeX) //TODO: always true
+		// NOTE: next condition is generally true (no pawn on last rank)
+		if (x+shiftX >= 0 && x+shiftX < sizeX)
 		{
 			const finalPieces = x + shiftX == lastRank
 				? [V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN]
@@ -956,11 +973,28 @@ class ChessRules
 			board[psq.x][psq.y] = psq.c + psq.p;
 	}
 
-	// Before move is played, update variables + flags
+	// After move is played, update variables + flags
 	updateVariables(move)
 	{
-		const piece = move.vanish[0].p;
-		const c = move.vanish[0].c;
+		let piece = undefined;
+		let c = undefined;
+		if (move.vanish.length >= 1)
+		{
+			// Usual case, something is moved
+			piece = move.vanish[0].p;
+			c = move.vanish[0].c;
+		}
+		else
+		{
+			// Crazyhouse-like variants
+			piece = move.appear[0].p;
+			c = move.appear[0].c;
+		}
+		if (c == "c") //if (!["w","b"].includes(c))
+		{
+			// 'c = move.vanish[0].c' doesn't work for Checkered
+			c = this.getOppCol(this.turn);
+		}
 		const firstRank = (c == "w" ? V.size.x-1 : 0);
 
 		// Update king position + flags
@@ -968,22 +1002,27 @@ class ChessRules
 		{
 			this.kingPos[c][0] = move.appear[0].x;
 			this.kingPos[c][1] = move.appear[0].y;
-			this.castleFlags[c] = [false,false];
+			if (V.HasFlags)
+				this.castleFlags[c] = [false,false];
 			return;
 		}
-		const oppCol = this.getOppCol(c);
-		const oppFirstRank = (V.size.x-1) - firstRank;
-		if (move.start.x == firstRank //our rook moves?
-			&& this.INIT_COL_ROOK[c].includes(move.start.y))
-		{
-			const flagIdx = (move.start.y == this.INIT_COL_ROOK[c][0] ? 0 : 1);
-			this.castleFlags[c][flagIdx] = false;
-		}
-		else if (move.end.x == oppFirstRank //we took opponent rook?
-			&& this.INIT_COL_ROOK[oppCol].includes(move.end.y))
+		if (V.HasFlags)
 		{
-			const flagIdx = (move.end.y == this.INIT_COL_ROOK[oppCol][0] ? 0 : 1);
-			this.castleFlags[oppCol][flagIdx] = false;
+			// Update castling flags if rooks are moved
+			const oppCol = this.getOppCol(c);
+			const oppFirstRank = (V.size.x-1) - firstRank;
+			if (move.start.x == firstRank //our rook moves?
+				&& this.INIT_COL_ROOK[c].includes(move.start.y))
+			{
+				const flagIdx = (move.start.y == this.INIT_COL_ROOK[c][0] ? 0 : 1);
+				this.castleFlags[c][flagIdx] = false;
+			}
+			else if (move.end.x == oppFirstRank //we took opponent rook?
+				&& this.INIT_COL_ROOK[oppCol].includes(move.end.y))
+			{
+				const flagIdx = (move.end.y == this.INIT_COL_ROOK[oppCol][0] ? 0 : 1);
+				this.castleFlags[oppCol][flagIdx] = false;
+			}
 		}
 	}
 
@@ -1004,7 +1043,7 @@ class ChessRules
 //		if (!ingame) this.states.push(this.getFen());
 
 		if (!!ingame)
-			move.notation = [this.getNotation(move), this.getLongNotation(move)];
+			move.notation = this.getNotation(move);
 
 		if (V.HasFlags)
 			move.flags = JSON.stringify(this.aggregateFlags()); //save flags (for undo)
@@ -1012,7 +1051,7 @@ class ChessRules
 			this.epSquares.push( this.getEpSquare(move) );
 		V.PlayOnBoard(this.board, move);
 		this.turn = this.getOppCol(this.turn);
-		this.moves.push(move);
+		this.movesCount++;
 		this.updateVariables(move);
 
 		if (!!ingame)
@@ -1030,7 +1069,7 @@ class ChessRules
 			this.disaggregateFlags(JSON.parse(move.flags));
 		V.UndoOnBoard(this.board, move);
 		this.turn = this.getOppCol(this.turn);
-		this.moves.pop();
+		this.movesCount--;
 		this.unupdateVariables(move);
 
 		// DEBUG:
@@ -1042,32 +1081,9 @@ class ChessRules
 	///////////////
 	// END OF GAME
 
-	// Check for 3 repetitions (position + flags + turn)
-	checkRepetition()
-	{
-		if (!this.hashStates)
-			this.hashStates = {};
-		const startIndex =
-			Object.values(this.hashStates).reduce((a,b) => { return a+b; }, 0)
-		// Update this.hashStates with last move (or all moves if continuation)
-		// NOTE: redundant storage, but faster and moderate size
-		for (let i=startIndex; i<this.moves.length; i++)
-		{
-			const move = this.moves[i];
-			if (!this.hashStates[move.hash])
-				this.hashStates[move.hash] = 1;
-			else
-				this.hashStates[move.hash]++;
-		}
-		return Object.values(this.hashStates).some(elt => { return (elt >= 3); });
-	}
-
 	// Is game over ? And if yes, what is the score ?
 	checkGameOver()
 	{
-		if (this.checkRepetition())
-			return "1/2";
-
 		if (this.atLeastOneMove()) // game not over
 			return "*";
 
@@ -1083,7 +1099,7 @@ class ChessRules
 		if (!this.isAttacked(this.kingPos[color], [this.getOppCol(color)]))
 			return "1/2";
 		// OK, checkmate
-		return color == "w" ? "0-1" : "1-0";
+		return (color == "w" ? "0-1" : "1-0");
 	}
 
 	///////////////
@@ -1211,7 +1227,7 @@ class ChessRules
 		}
 		else
 			return currentBest;
-		//console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
+//		console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
 
 		candidates = [0];
 		for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
@@ -1288,6 +1304,7 @@ class ChessRules
 	/////////////////////////
 
 	// Context: just before move is played, turn hasn't changed
+	// TODO: un-ambiguous notation (switch on piece type, check directions...)
 	getNotation(move)
 	{
 		if (move.appear.length == 2 && move.appear[0].p == V.KING) //castle
@@ -1330,36 +1347,33 @@ class ChessRules
 	}
 
 	// The score is already computed when calling this function
-	getPGN(mycolor, score, fenStart, mode)
+	getPGN(moves, mycolor, score, fenStart, mode)
 	{
 		let pgn = "";
-		pgn += '[Site "vchess.club"]<br>';
+		pgn += '[Site "vchess.club"]\n';
 		const opponent = mode=="human" ? "Anonymous" : "Computer";
-		pgn += '[Variant "' + variant + '"]<br>';
-		pgn += '[Date "' + getDate(new Date()) + '"]<br>';
-		pgn += '[White "' + (mycolor=='w'?'Myself':opponent) + '"]<br>';
-		pgn += '[Black "' + (mycolor=='b'?'Myself':opponent) + '"]<br>';
-		pgn += '[FenStart "' + fenStart + '"]<br>';
-		pgn += '[Fen "' + this.getFen() + '"]<br>';
-		pgn += '[Result "' + score + '"]<br><br>';
-
-		// Standard PGN
-		for (let i=0; i<this.moves.length; i++)
-		{
-			if (i % 2 == 0)
-				pgn += ((i/2)+1) + ".";
-			pgn += this.moves[i].notation[0] + " ";
-		}
-		pgn += "<br><br>";
-
-		// "Complete moves" PGN (helping in ambiguous cases)
-		for (let i=0; i<this.moves.length; i++)
+		pgn += '[Variant "' + variant + '"]\n';
+		pgn += '[Date "' + getDate(new Date()) + '"]\n';
+		// TODO: later when users are a bit less anonymous, use better names
+		const whiteName = ["human","computer"].includes(mode)
+			? (mycolor=='w'?'Myself':opponent)
+			: "analyze";
+		const blackName = ["human","computer"].includes(mode)
+			? (mycolor=='b'?'Myself':opponent)
+			: "analyze";
+		pgn += '[White "' + whiteName + '"]\n';
+		pgn += '[Black "' + blackName + '"]\n';
+		pgn += '[Fen "' + fenStart + '"]\n';
+		pgn += '[Result "' + score + '"]\n\n';
+
+		// Print moves
+		for (let i=0; i<moves.length; i++)
 		{
 			if (i % 2 == 0)
 				pgn += ((i/2)+1) + ".";
-			pgn += this.moves[i].notation[1] + " ";
+			pgn += moves[i].notation + " ";
 		}
 
-		return pgn;
+		return pgn + "\n";
 	}
 }