X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=public%2Fjavascripts%2Fvariants%2FMarseille.js;h=1adb83f4642ee28f41c9d4482fe29de8ca550a80;hb=26b8e4f7c71030d49e44fe1d89632ef91b886d67;hp=02daa22b8d416ba7ca131e14dbf6ec7700b98c97;hpb=78bab51e57306ae9085d83828bbb73b62dd83fd8;p=vchess.git

diff --git a/public/javascripts/variants/Marseille.js b/public/javascripts/variants/Marseille.js
index 02daa22b..1adb83f4 100644
--- a/public/javascripts/variants/Marseille.js
+++ b/public/javascripts/variants/Marseille.js
@@ -43,15 +43,13 @@ class MarseilleRules extends ChessRules
 		const parsedFen = V.ParseFen(fen);
 		this.setFlags(parsedFen.flags);
 		if (parsedFen.enpassant == "-")
-			this.epSquares = [ [undefined,undefined] ];
+			this.epSquares = [ [undefined] ];
 		else
 		{
 			let res = [];
 			const squares = parsedFen.enpassant.split(",");
 			for (let sq of squares)
 				res.push(V.SquareToCoords(sq));
-			if (res.length == 1)
-				res.push(undefined); //always 2 slots in epSquares[i]
 			this.epSquares = [ res ];
 		}
 		this.scanKingsRooks(fen);
@@ -72,41 +70,37 @@ class MarseilleRules extends ChessRules
 		const firstRank = (color == 'w' ? sizeX-1 : 0);
 		const startRank = (color == "w" ? sizeX-2 : 1);
 		const lastRank = (color == "w" ? 0 : sizeX-1);
-		const pawnColor = this.getColor(x,y); //can be different for checkered
+		const finalPieces = x + shiftX == lastRank
+			? [V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN]
+			: [V.PAWN];
 
-		if (x+shiftX >= 0 && x+shiftX < sizeX) //TODO: always true
+		// One square forward
+		if (this.board[x+shiftX][y] == V.EMPTY)
 		{
-			const finalPieces = x + shiftX == lastRank
-				? [V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN]
-				: [V.PAWN]
-			// One square forward
-			if (this.board[x+shiftX][y] == V.EMPTY)
+			for (let piece of finalPieces)
 			{
-				for (let piece of finalPieces)
-				{
-					moves.push(this.getBasicMove([x,y], [x+shiftX,y],
-						{c:pawnColor,p:piece}));
-				}
-				// Next condition because pawns on 1st rank can generally jump
-				if ([startRank,firstRank].includes(x)
-					&& this.board[x+2*shiftX][y] == V.EMPTY)
-				{
-					// Two squares jump
-					moves.push(this.getBasicMove([x,y], [x+2*shiftX,y]));
-				}
+				moves.push(this.getBasicMove([x,y], [x+shiftX,y],
+					{c:color,p:piece}));
 			}
-			// Captures
-			for (let shiftY of [-1,1])
+			// Next condition because pawns on 1st rank can generally jump
+			if ([startRank,firstRank].includes(x)
+				&& this.board[x+2*shiftX][y] == V.EMPTY)
 			{
-				if (y + shiftY >= 0 && y + shiftY < sizeY
-					&& this.board[x+shiftX][y+shiftY] != V.EMPTY
-					&& this.canTake([x,y], [x+shiftX,y+shiftY]))
+				// Two squares jump
+				moves.push(this.getBasicMove([x,y], [x+2*shiftX,y]));
+			}
+		}
+		// Captures
+		for (let shiftY of [-1,1])
+		{
+			if (y + shiftY >= 0 && y + shiftY < sizeY
+				&& this.board[x+shiftX][y+shiftY] != V.EMPTY
+				&& this.canTake([x,y], [x+shiftX,y+shiftY]))
+			{
+				for (let piece of finalPieces)
 				{
-					for (let piece of finalPieces)
-					{
-						moves.push(this.getBasicMove([x,y], [x+shiftX,y+shiftY],
-							{c:pawnColor,p:piece}));
-					}
+					moves.push(this.getBasicMove([x,y], [x+shiftX,y+shiftY],
+						{c:color,p:piece}));
 				}
 			}
 		}
@@ -123,20 +117,24 @@ class MarseilleRules extends ChessRules
 		});
 		if (epSqs.length == 0)
 			return moves;
+		const oppCol = V.GetOppCol(color);
 		for (let sq of epSqs)
 		{
 			if (this.subTurn == 1 || (epSqs.length == 2 &&
 				// Was this en-passant capture already played at subturn 1 ?
+				// (Or maybe the opponent filled the en-passant square with a piece)
 				this.board[epSqs[0].x][epSqs[0].y] != V.EMPTY))
 			{
-				if (sq.x == x+shiftX && Math.abs(sq.y - y) == 1)
+				if (sq.x == x+shiftX && Math.abs(sq.y - y) == 1
+					// Add condition "enemy pawn must be present"
+					&& this.getPiece(x,sq.y) == V.PAWN && this.getColor(x,sq.y) == oppCol)
 				{
 					let epMove = this.getBasicMove([x,y], [sq.x,sq.y]);
 					epMove.vanish.push({
 						x: x,
 						y: sq.y,
 						p: 'p',
-						c: this.getColor(x,sq.y)
+						c: oppCol
 					});
 					moves.push(epMove);
 				}
@@ -148,85 +146,91 @@ class MarseilleRules extends ChessRules
 
 	play(move, ingame)
 	{
-//		console.log("play " + this.getNotation(move));
-//		console.log(this.turn + " "+ this.subTurn);
 		if (!!ingame)
-			move.notation = [this.getNotation(move), this.getLongNotation(move)];
-		move.flags = JSON.stringify(this.aggregateFlags());
-		let lastEpsq = this.epSquares[this.epSquares.length-1];
-		const epSq = this.getEpSquare(move);
-		if (lastEpsq.length == 1)
-			lastEpsq.push(epSq);
-		else
 		{
-			// New turn
-			let newEpsqs = [epSq];
-			if (this.startAtFirstMove && this.moves.length == 0)
-				newEpsqs.push(undefined); //at first move, to force length==2 (TODO)
-			this.epSquares.push(newEpsqs);
+			move.notation = [this.getNotation(move), this.getLongNotation(move)];
+			// In this special case, we also need the "move color":
+			move.color = this.turn;
 		}
+		move.flags = JSON.stringify(this.aggregateFlags());
 		V.PlayOnBoard(this.board, move);
+		const epSq = this.getEpSquare(move);
 		if (this.startAtFirstMove && this.moves.length == 0)
+		{
 			this.turn = "b";
+			this.epSquares.push([epSq]);
+		}
 		// Does this move give check on subturn 1? If yes, skip subturn 2
-		else if (this.subTurn==1 && this.underCheck(this.getOppCol(this.turn)))
+		else if (this.subTurn==1 && this.underCheck(V.GetOppCol(this.turn)))
 		{
-			this.epSquares[this.epSquares.length-1].push(undefined);
-			this.turn = this.getOppCol(this.turn);
+			this.turn = V.GetOppCol(this.turn);
+			this.epSquares.push([epSq]);
 			move.checkOnSubturn1 = true;
 		}
 		else
 		{
 			if (this.subTurn == 2)
-				this.turn = this.getOppCol(this.turn);
+			{
+				this.turn = V.GetOppCol(this.turn);
+				let lastEpsq = this.epSquares[this.epSquares.length-1];
+				lastEpsq.push(epSq);
+			}
+			else
+				this.epSquares.push([epSq]);
 			this.subTurn = 3 - this.subTurn;
 		}
 		this.moves.push(move);
 		this.updateVariables(move);
 		if (!!ingame)
 			move.hash = hex_md5(this.getFen());
-		//console.log(move.checkOnSubturn1 + " " +this.turn + " "+ this.subTurn);
 	}
 
 	undo(move)
 	{
 		this.disaggregateFlags(JSON.parse(move.flags));
-		let lastEpsq = this.epSquares[this.epSquares.length-1];
-		if (lastEpsq.length == 2)
-		{
-			if (!!move.checkOnSubturn1 ||
-				(this.startAtFirstMove && this.moves.length == 1))
-			{
-				this.epSquares.pop(); //remove real + artificial e.p. squares
-			}
-			else
-				lastEpsq.pop();
-		}
-		else
-			this.epSquares.pop();
 		V.UndoOnBoard(this.board, move);
 		if (this.startAtFirstMove && this.moves.length == 1)
+		{
 			this.turn = "w";
+			this.epSquares.pop();
+		}
 		else if (move.checkOnSubturn1)
 		{
-			this.turn = this.getOppCol(this.turn);
+			this.turn = V.GetOppCol(this.turn);
 			this.subTurn = 1;
+			this.epSquares.pop();
 		}
 		else
 		{
 			if (this.subTurn == 1)
-				this.turn = this.getOppCol(this.turn);
+			{
+				this.turn = V.GetOppCol(this.turn);
+				let lastEpsq = this.epSquares[this.epSquares.length-1];
+				lastEpsq.pop();
+			}
+			else
+				this.epSquares.pop();
 			this.subTurn = 3 - this.subTurn;
 		}
 		this.moves.pop();
 		this.unupdateVariables(move);
-//		console.log("UNDO " + this.getNotation(move));
-//		console.log(this.turn + " "+ this.subTurn);
 	}
 
 	// NOTE:  GenRandInitFen() is OK,
 	// since at first move turn indicator is just "w"
 
+	static get VALUES()
+	{
+		return {
+			'p': 1,
+			'r': 5,
+			'n': 3,
+			'b': 3,
+			'q': 7, //slightly less than in orthodox game
+			'k': 1000
+		};
+	}
+
 	// No alpha-beta here, just adapted min-max at depth 2(+1)
 	getComputerMove()
 	{
@@ -235,10 +239,11 @@ class MarseilleRules extends ChessRules
 
 		const maxeval = V.INFINITY;
 		const color = this.turn;
-		const oppCol = this.getOppCol(this.turn);
+		const oppCol = V.GetOppCol(this.turn);
 
 		// Search best (half) move for opponent turn
 		const getBestMoveEval = () => {
+			const turnBefore = this.turn + this.subTurn;
 			let moves = this.getAllValidMoves();
 			if (moves.length == 0)
 			{
@@ -251,7 +256,8 @@ class MarseilleRules extends ChessRules
 			for (let m of moves)
 			{
 				this.play(m);
-				this.turn = color; //very artificial...
+				// Now turn is oppCol,2 if m doesn't give check
+				// Otherwise it's color,1. In both cases the next test makes sense
 				if (!this.atLeastOneMove())
 				{
 					const score = this.checkGameEnd();
@@ -260,14 +266,12 @@ class MarseilleRules extends ChessRules
 					else
 					{
 						// Found a mate
-						this.turn = oppCol;
 						this.undo(m);
 						return maxeval * (score == "1-0" ? 1 : -1);
 					}
 				}
 				const evalPos = this.evalPosition();
 				res = (oppCol == "w" ? Math.max(res, evalPos) : Math.min(res, evalPos));
-				this.turn = oppCol;
 				this.undo(m);
 			}
 			return res;
@@ -278,7 +282,6 @@ class MarseilleRules extends ChessRules
 		// Rank moves using a min-max at depth 2
 		for (let i=0; i<moves11.length; i++)
 		{
-			moves11[i].eval = (color=="w" ? -1 : 1) * maxeval;
 			this.play(moves11[i]);
 			if (this.turn != color)
 			{
@@ -315,6 +318,60 @@ class MarseilleRules extends ChessRules
 			return selected[0];
 		return selected;
 	}
+
+	getPGN(mycolor, score, fenStart, mode)
+	{
+		let pgn = "";
+		pgn += '[Site "vchess.club"]\n';
+		const opponent = mode=="human" ? "Anonymous" : "Computer";
+		pgn += '[Variant "' + variant + '"]\n';
+		pgn += '[Date "' + getDate(new Date()) + '"]\n';
+		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 += '[FenStart "' + fenStart + '"]\n';
+		pgn += '[Fen "' + this.getFen() + '"]\n';
+		pgn += '[Result "' + score + '"]\n\n';
+
+		let counter = 1;
+		let i = 0;
+		while (i < this.moves.length)
+		{
+			pgn += (counter++) + ".";
+			for (let color of ["w","b"])
+			{
+				let move = "";
+				while (i < this.moves.length && this.moves[i].color == color)
+					move += this.moves[i++].notation[0] + ",";
+				move = move.slice(0,-1); //remove last comma
+				pgn += move + (i < this.moves.length-1 ? " " : "");
+			}
+		}
+		pgn += "\n\n";
+
+		// "Complete moves" PGN (helping in ambiguous cases)
+		counter = 1;
+		i = 0;
+		while (i < this.moves.length)
+		{
+			pgn += (counter++) + ".";
+			for (let color of ["w","b"])
+			{
+				let move = "";
+				while (i < this.moves.length && this.moves[i].color == color)
+					move += this.moves[i++].notation[1] + ",";
+				move = move.slice(0,-1); //remove last comma
+				pgn += move + (i < this.moves.length-1 ? " " : "");
+			}
+		}
+
+		return pgn + "\n";
+	}
 }
 
 const VariantRules = MarseilleRules;