X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=backend.c;h=26ebe3cc49562e90042c511f8638f1ad0320c812;hb=f29ff21f23c2a22fc55e14ba48c53d704c22289d;hp=eaaa87aea8e095f335dd2eb3918864feab8ad582;hpb=fd1213c4557770ea82b25e443230345f50dfb97c;p=xboard.git

diff --git a/backend.c b/backend.c
index eaaa87a..26ebe3c 100644
--- a/backend.c
+++ b/backend.c
@@ -63,6 +63,7 @@ int flock(int f, int code);
 
 #else
 
+#include <sys/file.h>
 #define DoSleep( n ) if( (n) >= 0) sleep(n)
 #define SLASH '/'
 
@@ -233,7 +234,7 @@ void InitDrawingSizes(int x, int y);
 void NextMatchGame P((void));
 int NextTourneyGame P((int nr, int *swap));
 int Pairing P((int nr, int nPlayers, int *w, int *b, int *sync));
-FILE *WriteTourneyFile P((char *results));
+FILE *WriteTourneyFile P((char *results, FILE *f));
 void DisplayTwoMachinesTitle P(());
 
 #ifdef WIN32
@@ -980,6 +981,7 @@ InitBackEnd1()
 
     GetTimeMark(&programStartTime);
     srandom((programStartTime.ms + 1000*programStartTime.sec)*0x1001001); // [HGM] book: makes sure random is unpredictabe to msec level
+    appData.seedBase = random() + (random()<<15);
     pauseStart = programStartTime; pauseStart.sec -= 100; // [HGM] matchpause: fake a pause that has long since ended
 
     ClearProgramStats();
@@ -1435,7 +1437,7 @@ MatchEvent(int mode)
 		if(strchr(appData.results, '*') == NULL) {
 		    FILE *f;
 		    appData.tourneyCycles++;
-		    if(f = WriteTourneyFile(appData.results)) { // make a tourney file with increased number of cycles
+		    if(f = WriteTourneyFile(appData.results, NULL)) { // make a tourney file with increased number of cycles
 			fclose(f);
 			NextTourneyGame(-1, &dummy);
 			ReserveGame(-1, 0);
@@ -4860,6 +4862,11 @@ SendMoveToProgram(moveNum, cps)
 {
     char buf[MSG_SIZ];
 
+    if(moveList[moveNum][1] == '@' && moveList[moveNum][0] == '@') {
+	// null move in variant where engine does not understand it (for analysis purposes)
+	SendBoard(cps, moveNum + 1); // send position after move in stead.
+	return;
+    }
     if (cps->useUsermove) {
       SendToProgram("usermove ", cps);
     }
@@ -4900,6 +4907,7 @@ SendMoveToProgram(moveNum, cps)
       } else
       if(BOARD_HEIGHT > 10) { // [HGM] big: convert ranks to double-digit where needed
 	if(moveList[moveNum][1] == '@' && (BOARD_HEIGHT < 16 || moveList[moveNum][0] <= 'Z')) { // drop move
+	  if(moveList[moveNum][0]== '@') snprintf(buf, MSG_SIZ, "@@@@\n"); else
 	  snprintf(buf, MSG_SIZ, "%c@%c%d%s", moveList[moveNum][0],
 					      moveList[moveNum][2], moveList[moveNum][3] - '0', moveList[moveNum]+4);
 	} else
@@ -5075,6 +5083,7 @@ CoordsToComputerAlgebraic(rf, ff, rt, ft, promoChar, move)
      char move[7];
 {
     if (rf == DROP_RANK) {
+      if(ff == EmptySquare) sprintf(move, "@@@@\n"); else // [HGM] pass
       sprintf(move, "%c@%c%c\n",
                 ToUpper(PieceToChar((ChessSquare) ff)), AAA + ft, ONE + rt);
     } else {
@@ -6223,7 +6232,6 @@ OKToStartUserMove(x, y)
       (int)from_piece < (int)BlackPawn; /* [HGM] can be > King! */
 
     switch (gameMode) {
-      case PlayFromGameFile:
       case AnalyzeFile:
       case TwoMachinesPlay:
       case EndOfGame:
@@ -6251,6 +6259,8 @@ OKToStartUserMove(x, y)
 	}
 	break;
 
+      case PlayFromGameFile:
+	    if(!shiftKey || !appData.variations) return FALSE; // [HGM] allow starting variation in this mode
       case EditGame:
 	if (!white_piece && WhiteOnMove(currentMove)) {
 	    DisplayMoveError(_("It is White's turn"));
@@ -6294,6 +6304,7 @@ OKToStartUserMove(x, y)
     }
     if (currentMove != forwardMostMove && gameMode != AnalyzeMode
 	&& gameMode != EditGame // [HGM] vari: treat as AnalyzeMode
+	&& gameMode != PlayFromGameFile // [HGM] as EditGame, with protected main line
 	&& gameMode != AnalyzeFile && gameMode != Training) {
 	DisplayMoveError(_("Displayed position is not current"));
 	return FALSE;
@@ -6385,7 +6396,6 @@ UserMoveEvent(fromX, fromY, toX, toY, promoChar)
        */
 
     switch (gameMode) {
-      case PlayFromGameFile:
       case AnalyzeFile:
       case TwoMachinesPlay:
       case EndOfGame:
@@ -6411,6 +6421,8 @@ UserMoveEvent(fromX, fromY, toX, toY, promoChar)
 	}
 	break;
 
+      case PlayFromGameFile:
+	    if(!shiftKey ||!appData.variations) return; // [HGM] only variations
       case EditGame:
       case IcsExamining:
       case BeginningOfGame:
@@ -6526,6 +6538,9 @@ UserMoveEvent(fromX, fromY, toX, toY, promoChar)
     /* [HGM] always test for legality, to get promotion info */
     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
                                          fromY, fromX, toY, toX, promoChar);
+
+    if(fromY == DROP_RANK && fromX == EmptySquare && (gameMode == AnalyzeMode || gameMode == EditGame)) moveType = NormalMove;
+
     /* [HGM] but possibly ignore an IllegalMove result */
     if (appData.testLegality) {
 	if (moveType == IllegalMove || moveType == ImpossibleMove) {
@@ -6602,7 +6617,7 @@ FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
 
   /* Ok, now we know that the move is good, so we can kill
      the previous line in Analysis Mode */
-  if ((gameMode == AnalyzeMode || gameMode == EditGame)
+  if ((gameMode == AnalyzeMode || gameMode == EditGame || gameMode == PlayFromGameFile && appData.variations && shiftKey)
 				&& currentMove < forwardMostMove) {
     if(appData.variations && shiftKey) PushTail(currentMove, forwardMostMove); // [HGM] vari: save tail of game
     else forwardMostMove = currentMove;
@@ -6667,6 +6682,9 @@ FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
 	 // [HGM] book: if program might be playing, let it use book
 	bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
 	first.maybeThinking = TRUE;
+    } else if(fromY == DROP_RANK && fromX == EmptySquare) {
+	if(!first.useSetboard) SendToProgram("undo\n", &first); // kludge to change stm in engines that do not support setboard
+	SendBoard(&first, currentMove+1);
     } else SendMoveToProgram(forwardMostMove-1, &first);
     if (currentMove == cmailOldMove + 1) {
       cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
@@ -6744,7 +6762,7 @@ void
 MarkTargetSquares(int clear)
 {
   int x, y;
-  if(!appData.markers || !appData.highlightDragging ||
+  if(!appData.markers || !appData.highlightDragging || appData.icsActive && gameInfo.variant < VariantShogi ||
      !appData.testLegality || gameMode == EditPosition) return;
   if(clear) {
     for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) marker[y][x] = 0;
@@ -7136,7 +7154,7 @@ int RightClick(ClickType action, int x, int y, int *fromX, int *fromY)
 	toX = xSqr; toY = ySqr; lastX = x, lastY = y;
 	if(flipView) toX = BOARD_WIDTH - 1 - toX; else toY = BOARD_HEIGHT - 1 - toY;
 	NextPiece(0);
-	return -2;
+	return 2; // grab
       case IcsObserving:
 	if(!appData.icsEngineAnalyze) return -1;
       case IcsPlayingWhite:
@@ -7357,6 +7375,28 @@ MatingPotential(int pCnt[], int side, int nMine, int nHis, int stale, int bisCol
 }
 
 int
+CompareWithRights(Board b1, Board b2)
+{
+    int rights = 0;
+    if(!CompareBoards(b1, b2)) return FALSE;
+    if(b1[EP_STATUS] != b2[EP_STATUS]) return FALSE;
+    /* compare castling rights */
+    if( b1[CASTLING][2] != b2[CASTLING][2] && (b2[CASTLING][0] != NoRights || b2[CASTLING][1] != NoRights) )
+           rights++; /* King lost rights, while rook still had them */
+    if( b1[CASTLING][2] != NoRights ) { /* king has rights */
+        if( b1[CASTLING][0] != b2[CASTLING][0] || b1[CASTLING][1] != b2[CASTLING][1] )
+           rights++; /* but at least one rook lost them */
+    }
+    if( b1[CASTLING][5] != b1[CASTLING][5] && (b2[CASTLING][3] != NoRights || b2[CASTLING][4] != NoRights) )
+           rights++;
+    if( b1[CASTLING][5] != NoRights ) {
+        if( b1[CASTLING][3] != b2[CASTLING][3] || b1[CASTLING][4] != b2[CASTLING][4] )
+           rights++;
+    }
+    return rights == 0;
+}
+
+int
 Adjudicate(ChessProgramState *cps)
 {	// [HGM] some adjudications useful with buggy engines
 	// [HGM] adjudicate: made into separate routine, which now can be called after every move
@@ -9005,15 +9045,19 @@ ApplyMove(fromX, fromY, toX, toY, promoChar, board)
       oldEP = (signed char)board[EP_STATUS];
       board[EP_STATUS] = EP_NONE;
 
-      if( board[toY][toX] != EmptySquare )
-           board[EP_STATUS] = EP_CAPTURE;
-
   if (fromY == DROP_RANK) {
 	/* must be first */
+        if(fromX == EmptySquare) { // [HGM] pass: empty drop encodes null move; nothing to change.
+	    board[EP_STATUS] = EP_CAPTURE; // null move considered irreversible
+	    return;
+	}
         piece = board[toY][toX] = (ChessSquare) fromX;
   } else {
       int i;
 
+      if( board[toY][toX] != EmptySquare )
+           board[EP_STATUS] = EP_CAPTURE;
+
       if( board[fromY][fromX] == WhiteLance || board[fromY][fromX] == BlackLance ) {
            if( gameInfo.variant != VariantSuper && gameInfo.variant != VariantShogi )
                board[EP_STATUS] = EP_PAWN_MOVE; // Lance is Pawn-like in most variants
@@ -9677,12 +9721,13 @@ CountPlayers(char *p)
 }
 
 FILE *
-WriteTourneyFile(char *results)
+WriteTourneyFile(char *results, FILE *f)
 {   // write tournament parameters on tourneyFile; on success return the stream pointer for closing
-    FILE *f = fopen(appData.tourneyFile, "w");
+    if(f == NULL) f = fopen(appData.tourneyFile, "w");
     if(f == NULL) DisplayError(_("Could not write on tourney file"), 0); else {
 	// create a file with tournament description
 	fprintf(f, "-participants {%s}\n", appData.participants);
+	fprintf(f, "-seedBase %d\n", appData.seedBase);
 	fprintf(f, "-tourneyType %d\n", appData.tourneyType);
 	fprintf(f, "-tourneyCycles %d\n", appData.tourneyCycles);
 	fprintf(f, "-defaultMatchGames %d\n", appData.defaultMatchGames);
@@ -9706,10 +9751,73 @@ WriteTourneyFile(char *results)
     return f;
 }
 
+#define MAXENGINES 1000
+char *command[MAXENGINES], *mnemonic[MAXENGINES];
+
+void Substitute(char *participants, int expunge)
+{
+    int i, changed, changes=0, nPlayers=0;
+    char *p, *q, *r, buf[MSG_SIZ];
+    if(participants == NULL) return;
+    if(appData.tourneyFile[0] == NULLCHAR) { free(participants); return; }
+    r = p = participants; q = appData.participants;
+    while(*p && *p == *q) {
+	if(*p == '\n') r = p+1, nPlayers++;
+	p++; q++;
+    }
+    if(*p) { // difference
+	while(*p && *p++ != '\n');
+	while(*q && *q++ != '\n');
+      changed = nPlayers;
+	changes = 1 + (strcmp(p, q) != 0);
+    }
+    if(changes == 1) { // a single engine mnemonic was changed
+	q = r; while(*q) nPlayers += (*q++ == '\n');
+	p = buf; while(*r && (*p = *r++) != '\n') p++;
+	*p = NULLCHAR;
+	NamesToList(firstChessProgramNames, command, mnemonic);
+	for(i=1; mnemonic[i]; i++) if(!strcmp(buf, mnemonic[i])) break;
+	if(mnemonic[i]) { // The substitute is valid
+	    FILE *f;
+	    if(appData.tourneyFile[0] && (f = fopen(appData.tourneyFile, "r+")) ) {
+		flock(fileno(f), LOCK_EX);
+		ParseArgsFromFile(f);
+		fseek(f, 0, SEEK_SET);
+		FREE(appData.participants); appData.participants = participants;
+		if(expunge) { // erase results of replaced engine
+		    int len = strlen(appData.results), w, b, dummy;
+		    for(i=0; i<len; i++) {
+			Pairing(i, nPlayers, &w, &b, &dummy);
+			if((w == changed || b == changed) && appData.results[i] == '*') {
+			    DisplayError(_("You cannot replace an engine while it is engaged!\nTerminate its game first."), 0);
+			    fclose(f);
+			    return;
+			}
+		    }
+		    for(i=0; i<len; i++) {
+			Pairing(i, nPlayers, &w, &b, &dummy);
+			if(w == changed || b == changed) appData.results[i] = ' '; // mark as not played
+		    }
+		}
+		WriteTourneyFile(appData.results, f);
+		fclose(f); // release lock
+		return;
+	    }
+	} else DisplayError(_("No engine with the name you gave is installed"), 0);
+    }
+    if(changes == 0) DisplayError(_("First change an engine by editing the participants list\nof the Tournament Options dialog"), 0);
+    if(changes > 1)  DisplayError(_("You can only change one engine at the time"), 0);
+    free(participants);
+    return;
+}
+
 int
 CreateTourney(char *name)
 {
 	FILE *f;
+	if(matchMode && strcmp(name, appData.tourneyFile)) {
+	     ASSIGN(name, appData.tourneyFile); //do not allow change of tourneyfile while playing
+	}
 	if(name[0] == NULLCHAR) {
 	    if(appData.participants[0])
 		DisplayError(_("You must supply a tournament file,\nfor storing the tourney progress"), 0);
@@ -9727,7 +9835,7 @@ CreateTourney(char *name)
 	    }
 	    ASSIGN(appData.tourneyFile, name);
 	    if(appData.tourneyType < 0) appData.defaultMatchGames = 1; // Swiss forces games/pairing = 1
-	    if((f = WriteTourneyFile("")) == NULL) return 0;
+	    if((f = WriteTourneyFile("", NULL)) == NULL) return 0;
 	}
 	fclose(f);
 	appData.noChessProgram = FALSE;
@@ -9736,9 +9844,6 @@ CreateTourney(char *name)
 	return 1;
 }
 
-#define MAXENGINES 1000
-char *command[MAXENGINES], *mnemonic[MAXENGINES];
-
 void NamesToList(char *names, char **engineList, char **engineMnemonic)
 {
     char buf[MSG_SIZ], *p, *q;
@@ -9761,7 +9866,7 @@ void NamesToList(char *names, char **engineList, char **engineMnemonic)
 	names = p; i++;
       if(i > MAXENGINES - 2) break;
     }
-    engineList[i] = NULL;
+    engineList[i] = engineMnemonic[i] = NULL;
 }
 
 // following implemented as macro to avoid type limitations
@@ -9923,6 +10028,7 @@ NextMatchGame()
     first.twoMachinesColor =  firstWhite ? "white\n" : "black\n";   // perform actual color assignement
     second.twoMachinesColor = firstWhite ? "black\n" : "white\n";
     appData.noChessProgram = (first.pr == NoProc); // kludge to prevent Reset from starting up chess program
+    if(appData.loadGameIndex == -2) srandom(appData.seedBase + 68163*(nextGame & ~1)); // deterministic seed to force same opening
     Reset(FALSE, first.pr != NoProc);
     appData.noChessProgram = FALSE;
     if(!LoadGameOrPosition(matchGame)) return; // setup game; abort when bad game/pos file
@@ -10444,6 +10550,7 @@ Reset(redraw, init)
 		redraw, init, gameMode);
     }
     CleanupTail(); // [HGM] vari: delete any stored variations
+    CommentPopDown(); // [HGM] make sure no comments to the previous game keep hanging on
     pausing = pauseExamInvalid = FALSE;
     startedFromSetupPosition = blackPlaysFirst = FALSE;
     firstMove = TRUE;
@@ -10551,8 +10658,8 @@ AutoPlayOneMove()
 
     if (currentMove >= forwardMostMove) {
       if(gameMode == AnalyzeFile) { ExitAnalyzeMode(); SendToProgram("force\n", &first); }
-      gameMode = EditGame;
-      ModeHighlight();
+//      gameMode = EndOfGame;
+//      ModeHighlight();
 
       /* [AS] Clear current move marker at the end of a game */
       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
@@ -10999,7 +11106,149 @@ ReloadGame(offset)
     }
 }
 
+int keys[EmptySquare+1];
 
+int
+PositionMatches(Board b1, Board b2)
+{
+    int r, f, sum=0;
+    switch(appData.searchMode) {
+	case 1: return CompareWithRights(b1, b2);
+	case 2:
+	    for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
+		if(b2[r][f] != EmptySquare && b1[r][f] != b2[r][f]) return FALSE;
+	    }
+	    return TRUE;
+	case 3:
+	    for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
+	      if((b2[r][f] == WhitePawn || b2[r][f] == BlackPawn) && b1[r][f] != b2[r][f]) return FALSE;
+		sum += keys[b1[r][f]] - keys[b2[r][f]];
+	    }
+	    return sum==0;
+	case 4:
+	    for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
+		sum += keys[b1[r][f]] - keys[b2[r][f]];
+	    }
+	    return sum==0;
+    }
+    return TRUE;
+}
+
+GameInfo dummyInfo;
+
+int GameContainsPosition(FILE *f, ListGame *lg)
+{
+    int next, btm=0, plyNr=0, scratch=forwardMostMove+2&~1;
+    int fromX, fromY, toX, toY;
+    char promoChar;
+    static int initDone=FALSE;
+
+    if(!initDone) {
+	for(next = WhitePawn; next<EmptySquare; next++) keys[next] = random()>>8 ^ random()<<6 ^random()<<20;
+	initDone = TRUE;
+    }
+    dummyInfo.variant = VariantNormal;
+    FREE(dummyInfo.fen); dummyInfo.fen = NULL;
+    dummyInfo.whiteRating = 0;
+    dummyInfo.blackRating = 0;
+    FREE(dummyInfo.date); dummyInfo.date = NULL;
+    fseek(f, lg->offset, 0);
+    yynewfile(f);
+    CopyBoard(boards[scratch], initialPosition); // default start position
+    while(1) {
+	yyboardindex = scratch + (plyNr&1);
+      quickFlag = 1;
+	next = Myylex();
+      quickFlag = 0;
+	switch(next) {
+	    case PGNTag:
+		if(plyNr) return -1; // after we have seen moves, any tags will be start of next game
+#if 0
+		ParsePGNTag(yy_text, &dummyInfo); // this has a bad memory leak...
+		if(dummyInfo.fen) ParseFEN(boards[scratch], &btm, dummyInfo.fen), free(dummyInfo.fen), dummyInfo.fen = NULL;
+#else
+		// do it ourselves avoiding malloc
+		{ char *p = yy_text+1, *q;
+		  while(!isdigit(*p) && !isalpha(*p)) p++;
+		  q  = p; while(*p != ' ' && *p != '\t' && *p != '\n') p++;
+		  *p = NULLCHAR;
+		  if(!StrCaseCmp(q, "Date") && (p = strchr(p+1, '"'))) { if(atoi(p+1) < appData.dateThreshold) return -1; } else
+		  if(!StrCaseCmp(q, "Variant")  &&  (p = strchr(p+1, '"'))) dummyInfo.variant = StringToVariant(p+1); else
+		  if(!StrCaseCmp(q, "WhiteElo")  && (p = strchr(p+1, '"'))) dummyInfo.whiteRating = atoi(p+1); else
+		  if(!StrCaseCmp(q, "BlackElo")  && (p = strchr(p+1, '"'))) dummyInfo.blackRating = atoi(p+1); else
+		  if(!StrCaseCmp(q, "WhiteUSCF") && (p = strchr(p+1, '"'))) dummyInfo.whiteRating = atoi(p+1); else
+		  if(!StrCaseCmp(q, "BlackUSCF") && (p = strchr(p+1, '"'))) dummyInfo.blackRating = atoi(p+1); else
+		  if(!StrCaseCmp(q, "FEN")  && (p = strchr(p+1, '"'))) ParseFEN(boards[scratch], &btm, p+1);
+		}
+#endif
+	    default:
+		continue;
+
+	    case XBoardGame:
+	    case GNUChessGame:
+		if(plyNr) return -1; // after we have seen moves, this is for new game
+	      continue;
+
+	    case AmbiguousMove: // we cannot reconstruct the game beyond these two
+	    case ImpossibleMove:
+	    case WhiteWins: // game ends here with these four
+	    case BlackWins:
+	    case GameIsDrawn:
+	    case GameUnfinished:
+		return -1;
+
+	    case IllegalMove:
+		if(appData.testLegality) return -1;
+	    case WhiteCapturesEnPassant:
+	    case BlackCapturesEnPassant:
+	    case WhitePromotion:
+	    case BlackPromotion:
+	    case WhiteNonPromotion:
+	    case BlackNonPromotion:
+	    case NormalMove:
+	    case WhiteKingSideCastle:
+	    case WhiteQueenSideCastle:
+	    case BlackKingSideCastle:
+	    case BlackQueenSideCastle:
+	    case WhiteKingSideCastleWild:
+	    case WhiteQueenSideCastleWild:
+	    case BlackKingSideCastleWild:
+	    case BlackQueenSideCastleWild:
+	    case WhiteHSideCastleFR:
+	    case WhiteASideCastleFR:
+	    case BlackHSideCastleFR:
+	    case BlackASideCastleFR:
+		fromX = currentMoveString[0] - AAA;
+		fromY = currentMoveString[1] - ONE;
+		toX = currentMoveString[2] - AAA;
+		toY = currentMoveString[3] - ONE;
+		promoChar = currentMoveString[4];
+		break;
+	    case WhiteDrop:
+	    case BlackDrop:
+		fromX = next == WhiteDrop ?
+		  (int) CharToPiece(ToUpper(currentMoveString[0])) :
+		  (int) CharToPiece(ToLower(currentMoveString[0]));
+		fromY = DROP_RANK;
+		toX = currentMoveString[2] - AAA;
+		toY = currentMoveString[3] - ONE;
+		break;
+	}
+	// Move encountered; peform it. We need to shuttle between two boards, as even/odd index determines side to move
+	if(plyNr == 0) { // but first figure out variant and initial position
+	    if(dummyInfo.variant != gameInfo.variant) return -1; // wrong variant
+	    if(appData.eloThreshold1 && (dummyInfo.whiteRating < appData.eloThreshold1 && dummyInfo.blackRating < appData.eloThreshold1)) return -1;
+	    if(appData.eloThreshold2 && (dummyInfo.whiteRating < appData.eloThreshold2 || dummyInfo.blackRating < appData.eloThreshold2)) return -1;
+	    if(appData.dateThreshold && (!dummyInfo.date || atoi(dummyInfo.date) < appData.dateThreshold)) return -1;
+	    if(btm) CopyBoard(boards[scratch+1], boards[scratch]), plyNr++;
+	    if(PositionMatches(boards[scratch + plyNr], boards[currentMove])) return plyNr;
+	}
+	CopyBoard(boards[scratch + (plyNr+1&1)], boards[scratch + (plyNr&1)]);
+	plyNr++;
+	ApplyMove(fromX, fromY, toX, toY, promoChar, boards[scratch + (plyNr&1)]);
+	if(PositionMatches(boards[scratch + (plyNr&1)], boards[currentMove])) return plyNr;
+    }
+}
 
 /* Load the nth game from open file f */
 int
@@ -11014,7 +11263,7 @@ LoadGame(f, gameNumber, title, useList)
     int gn = gameNumber;
     ListGame *lg = NULL;
     int numPGNTags = 0;
-    int err;
+    int err, pos = -1;
     GameMode oldGameMode;
     VariantClass oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
 
@@ -11040,6 +11289,7 @@ LoadGame(f, gameNumber, title, useList)
 	if (lg) {
 	    fseek(f, lg->offset, 0);
 	    GameListHighlight(gameNumber);
+	    pos = lg->position;
 	    gn = 1;
 	}
 	else {
@@ -11439,10 +11689,11 @@ LoadGame(f, gameNumber, title, useList)
       AnalyzeFileEvent();
     }
 
+    if (!matchMode && pos >= 0) {
+	ToNrEvent(pos); // [HGM] no autoplay if selected on position
+    } else
     if (matchMode || appData.timeDelay == 0) {
       ToEndEvent();
-      gameMode = EditGame;
-      ModeHighlight();
     } else if (appData.timeDelay > 0) {
       AutoPlayGameLoop();
     }
@@ -13558,7 +13809,9 @@ ClockClick(int which)
 	  if (gameMode == EditPosition || gameMode == IcsExamining) {
 	    if(!appData.pieceMenu && blackPlaysFirst) EditPositionMenuEvent(ClearBoard, 0, 0);
 	    SetBlackToPlayEvent();
-	  } else if (gameMode == EditGame || shiftKey) {
+	  } else if ((gameMode == AnalyzeMode || gameMode == EditGame) && !blackFlag && WhiteOnMove(currentMove)) {
+          UserMoveEvent((int)EmptySquare, DROP_RANK, 0, 0, 0); // [HGM] multi-move: if not out of time, enters null move
+	  } else if (shiftKey) {
 	    AdjustClock(which, -1);
 	  } else if (gameMode == IcsPlayingWhite ||
 	             gameMode == MachinePlaysBlack) {
@@ -13568,7 +13821,9 @@ ClockClick(int which)
 	  if (gameMode == EditPosition || gameMode == IcsExamining) {
 	    if(!appData.pieceMenu && !blackPlaysFirst) EditPositionMenuEvent(ClearBoard, 0, 0);
 	    SetWhiteToPlayEvent();
-	  } else if (gameMode == EditGame || shiftKey) {
+	  } else if ((gameMode == AnalyzeMode || gameMode == EditGame) && !whiteFlag && !WhiteOnMove(currentMove)) {
+          UserMoveEvent((int)EmptySquare, DROP_RANK, 0, 0, 0); // [HGM] multi-move
+	  } else if (shiftKey) {
 	    AdjustClock(which, -1);
 	  } else if (gameMode == IcsPlayingBlack ||
 	           gameMode == MachinePlaysWhite) {
@@ -13845,6 +14100,16 @@ BackwardInner(target)
     if (gameMode == EditGame || gameMode==AnalyzeMode ||
 	gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
 	while (currentMove > target) {
+	    if(moveList[currentMove-1][1] == '@' && moveList[currentMove-1][0] == '@') {
+		// null move cannot be undone. Reload program with move history before it.
+		int i;
+		for(i=target; i>backwardMostMove; i--) { // seek back to start or previous null move
+		    if(moveList[i-1][1] == '@' && moveList[i-1][0] == '@') break;
+		}
+		SendBoard(&first, i); 
+		for(currentMove=i; currentMove<target; currentMove++) SendMoveToProgram(currentMove, &first);
+		break;
+	    }
 	    SendToProgram("undo\n", &first);
 	    currentMove--;
 	}
@@ -15211,8 +15476,6 @@ DisplayComment(moveNumber, text)
      char *text;
 {
     char title[MSG_SIZ];
-    char buf[8000]; // comment can be long!
-    int score, depth;
 
     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
       safeStrCpy(title, "Comment", sizeof(title)/sizeof(title[0]));
@@ -15221,14 +15484,6 @@ DisplayComment(moveNumber, text)
 	      WhiteOnMove(moveNumber) ? " " : ".. ",
 	      parseList[moveNumber]);
     }
-    // [HGM] PV info: display PV info together with (or as) comment
-    if(moveNumber >= 0 && (depth = pvInfoList[moveNumber].depth) > 0) {
-      if(text == NULL) text = "";
-      score = pvInfoList[moveNumber].score;
-      snprintf(buf,sizeof(buf)/sizeof(buf[0]), "%s%.2f/%d %d\n%s", score>0 ? "+" : "", score/100.,
-	      depth, (pvInfoList[moveNumber].time+50)/100, text);
-      text = buf;
-    }
     if (text != NULL && (appData.autoDisplayComment || commentUp))
         CommentPopUp(title, text);
 }
@@ -16369,6 +16624,7 @@ int wrap(char *dest, char *src, int count, int width, int *lp)
 }
 
 // [HGM] vari: routines for shelving variations
+Boolean modeRestore = FALSE;
 
 void
 PushInner(int firstMove, int lastMove)
@@ -16412,6 +16668,7 @@ PushTail(int firstMove, int lastMove)
 
 	PushInner(firstMove, lastMove);
 	if(storedGames == 1) GreyRevert(FALSE);
+	if(gameMode == PlayFromGameFile) gameMode = EditGame, modeRestore = TRUE;
 }
 
 void
@@ -16420,8 +16677,8 @@ PopInner(Boolean annotate)
 	int i, j, nrMoves;
 	char buf[8000], moveBuf[20];
 
-	storedGames--;
-	ToNrEvent(savedFirst[storedGames]); // sets currentMove
+	ToNrEvent(savedFirst[storedGames-1]); // sets currentMove
+	storedGames--; // do this after ToNrEvent, to make sure HistorySet will refresh entire game after PopInner returns
 	nrMoves = savedLast[storedGames] - currentMove;
 	if(annotate) {
 		int cnt = 10;
@@ -16469,8 +16726,10 @@ PopTail(Boolean annotate)
 	CommentPopDown(); // make sure no stale variation comments to the destroyed line can remain open
 
 	PopInner(annotate);
+	if(currentMove < forwardMostMove) ForwardEvent(); else
+	HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
 
-	if(storedGames == 0) GreyRevert(TRUE);
+	if(storedGames == 0) { GreyRevert(TRUE); if(modeRestore) modeRestore = FALSE, gameMode = PlayFromGameFile; }
 	return TRUE;
 }
 
@@ -16497,7 +16756,7 @@ LoadVariation(int index, char *text)
 	char *p = text, *start = NULL, *end = NULL, wait = NULLCHAR;
 	int level = 0, move;
 
-	if(gameMode != EditGame && gameMode != AnalyzeMode) return;
+	if(gameMode != EditGame && gameMode != AnalyzeMode && gameMode != PlayFromGameFile) return;
 	// first find outermost bracketing variation
 	while(*p) { // hope I got this right... Non-nesting {} and [] can screen each other and nesting ()
 	    if(!wait) { // while inside [] pr {}, ignore everyting except matching closing ]}