X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=backend.c;h=42f434e61341daa9f32971c7e6dd690415b1d7e8;hb=f7e7dc832cce623d716a05b2be6c63c8cae541d7;hp=74898c8b5944946b9e877d3b905e6ca50ad45a26;hpb=f3a5209d4f73b8ee5fac814f343a82a5b0cc900d;p=xboard.git

diff --git a/backend.c b/backend.c
index 74898c8..42f434e 100644
--- a/backend.c
+++ b/backend.c
@@ -5,7 +5,7 @@
  * Massachusetts.
  *
  * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
- * 2007, 2008, 2009 Free Software Foundation, Inc.
+ * 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
  *
  * Enhancements Copyright 2005 Alessandro Scotti
  *
@@ -167,6 +167,7 @@ int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
 		   /*char*/int promoChar));
 void BackwardInner P((int target));
 void ForwardInner P((int target));
+int Adjudicate P((ChessProgramState *cps));
 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
 void EditPositionDone P((Boolean fakeRights));
 void PrintOpponents P((FILE *fp));
@@ -187,6 +188,7 @@ void DisplayMove P((int moveNumber));
 
 void ParseGameHistory P((char *game));
 void ParseBoard12 P((char *string));
+void KeepAlive P((void));
 void StartClocks P((void));
 void SwitchClocks P((void));
 void StopClocks P((void));
@@ -244,6 +246,7 @@ char endingGame = 0;    /* [HGM] crash: flag to prevent recursion of GameEnds()
 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS     */
 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
 int lastIndex = 0;      /* [HGM] autoinc: last game/position used in match mode */
+Boolean connectionAlive;/* [HGM] alive: ICS connection status from probing      */
 int opponentKibitzes;
 int lastSavedGame; /* [HGM] save: ID of game */
 char chatPartner[MAX_CHAT][MSG_SIZ]; /* [HGM] chat: list of chatting partners */
@@ -356,6 +359,7 @@ PosFlags(index)
   case VariantNoCastle:
   case VariantShatranj:
   case VariantCourier:
+  case VariantMakruk:
     flags &= ~F_ALL_CASTLE_OK;
     break;
   default:
@@ -489,10 +493,10 @@ ChessSquare  KnightmateArray[2][BOARD_FILES] = {
 };
 
 ChessSquare fairyArray[2][BOARD_FILES] = { /* [HGM] Queen side differs from King side */
-    { WhiteCannon, WhiteNightrider, WhiteAlfil, WhiteQueen,
+    { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
-    { BlackCannon, BlackNightrider, BlackAlfil, BlackQueen,
-	BlackKing, BlackBishop, BlackKnight, BlackRook }
+    { BlackLance, BlackAlfil, BlackMarshall, BlackAngel,
+	BlackKing, BlackMarshall, BlackAlfil, BlackLance }
 };
 
 ChessSquare ShatranjArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
@@ -502,6 +506,13 @@ ChessSquare ShatranjArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatr
         BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 };
 
+ChessSquare makrukArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
+    { WhiteRook, WhiteKnight, WhiteMan, WhiteKing,
+        WhiteFerz, WhiteMan, WhiteKnight, WhiteRook },
+    { BlackRook, BlackKnight, BlackMan, BlackFerz,
+        BlackKing, BlackMan, BlackKnight, BlackRook }
+};
+
 
 #if (BOARD_FILES>=10)
 ChessSquare ShogiArray[2][BOARD_FILES] = {
@@ -888,6 +899,7 @@ InitBackEnd1()
       case VariantAtomic:     /* should work except for win condition */
       case Variant3Check:     /* should work except for win condition */
       case VariantShatranj:   /* should work except for all win conditions */
+      case VariantMakruk:     /* should work except for daw countdown */
       case VariantBerolina:   /* might work if TestLegality is off */
       case VariantCapaRandom: /* should work */
       case VariantJanus:      /* should work */
@@ -1112,6 +1124,8 @@ InitBackEnd3 P((void))
 	  AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
 	fromUserISR =
 	  AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
+	if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
+	    ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
     } else if (appData.noChessProgram) {
 	SetNCPMode();
     } else {
@@ -1431,6 +1445,8 @@ read_from_player(isr, closure, message, count, error)
 void
 KeepAlive()
 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
+    if(!connectionAlive) DisplayFatalError("No response from ICS", 0, 1);
+    connectionAlive = FALSE; // only sticks if no response to 'date' command.
     SendToICS("date\n");
     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
 }
@@ -2048,6 +2064,203 @@ static int player2Rating = -1;
 ColorClass curColor = ColorNormal;
 int suppressKibitz = 0;
 
+// [HGM] seekgraph
+Boolean soughtPending = FALSE;
+Boolean seekGraphUp;
+#define MAX_SEEK_ADS 200
+#define SQUARE 0x80
+char *seekAdList[MAX_SEEK_ADS];
+int ratingList[MAX_SEEK_ADS], xList[MAX_SEEK_ADS], yList[MAX_SEEK_ADS], seekNrList[MAX_SEEK_ADS], zList[MAX_SEEK_ADS];
+float tcList[MAX_SEEK_ADS];
+char colorList[MAX_SEEK_ADS];
+int nrOfSeekAds = 0;
+int minRating = 1010, maxRating = 2800;
+int hMargin = 10, vMargin = 20, h, w;
+extern int squareSize, lineGap;
+
+void
+PlotSeekAd(int i)
+{
+	int x, y, color = 0, r = ratingList[i]; float tc = tcList[i];
+	xList[i] = yList[i] = -100; // outside graph, so cannot be clicked
+	if(r < minRating+100 && r >=0 ) r = minRating+100;
+	if(r > maxRating) r = maxRating;
+	if(tc < 1.) tc = 1.;
+	if(tc > 95.) tc = 95.;
+	x = (w-hMargin)* log(tc)/log(100.) + hMargin;
+	y = ((double)r - minRating)/(maxRating - minRating)
+	    * (h-vMargin-squareSize/8-1) + vMargin;
+	if(ratingList[i] < 0) y = vMargin + squareSize/4;
+	if(strstr(seekAdList[i], " u ")) color = 1;
+	if(!strstr(seekAdList[i], "lightning") && // for now all wilds same color
+	   !strstr(seekAdList[i], "bullet") &&
+	   !strstr(seekAdList[i], "blitz") &&
+	   !strstr(seekAdList[i], "standard") ) color = 2;
+	if(strstr(seekAdList[i], "(C) ")) color |= SQUARE; // plot computer seeks as squares
+	DrawSeekDot(xList[i]=x+3*(color&~SQUARE), yList[i]=h-1-y, colorList[i]=color);
+}
+
+void
+AddAd(char *handle, char *rating, int base, int inc,  char rated, char *type, int nr, Boolean plot)
+{
+	char buf[MSG_SIZ], *ext = "";
+	VariantClass v = StringToVariant(type);
+	if(strstr(type, "wild")) {
+	    ext = type + 4; // append wild number
+	    if(v == VariantFischeRandom) type = "chess960"; else
+	    if(v == VariantLoadable) type = "setup"; else
+	    type = VariantName(v);
+	}
+	sprintf(buf, "%s (%s) %d %d %c %s%s", handle, rating, base, inc, rated, type, ext);
+	if(nrOfSeekAds < MAX_SEEK_ADS-1) {
+	    if(seekAdList[nrOfSeekAds]) free(seekAdList[nrOfSeekAds]);
+	    ratingList[nrOfSeekAds] = -1; // for if seeker has no rating
+	    sscanf(rating, "%d", &ratingList[nrOfSeekAds]);
+	    tcList[nrOfSeekAds] = base + (2./3.)*inc;
+	    seekNrList[nrOfSeekAds] = nr;
+	    zList[nrOfSeekAds] = 0;
+	    seekAdList[nrOfSeekAds++] = StrSave(buf);
+	    if(plot) PlotSeekAd(nrOfSeekAds-1);
+	}
+}
+
+void
+EraseSeekDot(int i)
+{
+    int x = xList[i], y = yList[i], d=squareSize/4, k;
+    DrawSeekBackground(x-squareSize/8, y-squareSize/8, x+squareSize/8+1, y+squareSize/8+1);
+    if(x < hMargin+d) DrawSeekAxis(hMargin, y-squareSize/8, hMargin, y+squareSize/8+1);
+    // now replot every dot that overlapped
+    for(k=0; k<nrOfSeekAds; k++) if(k != i) {
+	int xx = xList[k], yy = yList[k];
+	if(xx <= x+d && xx > x-d && yy <= y+d && yy > y-d)
+	    DrawSeekDot(xx, yy, colorList[k]);
+    }
+}
+
+void
+RemoveSeekAd(int nr)
+{
+	int i;
+	for(i=0; i<nrOfSeekAds; i++) if(seekNrList[i] == nr) {
+	    EraseSeekDot(i);
+	    if(seekAdList[i]) free(seekAdList[i]);
+	    seekAdList[i] = seekAdList[--nrOfSeekAds];
+	    seekNrList[i] = seekNrList[nrOfSeekAds];
+	    ratingList[i] = ratingList[nrOfSeekAds];
+	    colorList[i]  = colorList[nrOfSeekAds];
+	    tcList[i] = tcList[nrOfSeekAds];
+	    xList[i]  = xList[nrOfSeekAds];
+	    yList[i]  = yList[nrOfSeekAds];
+	    zList[i]  = zList[nrOfSeekAds];
+	    seekAdList[nrOfSeekAds] = NULL;
+	    break;
+	}
+}
+
+Boolean
+MatchSoughtLine(char *line)
+{
+    char handle[MSG_SIZ], rating[MSG_SIZ], type[MSG_SIZ];
+    int nr, base, inc, u=0; char dummy;
+
+    if(sscanf(line, "%d %s %s %d %d rated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
+       sscanf(line, "%d %s %s %s %d %d rated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7 ||
+       (u=1) &&
+       (sscanf(line, "%d %s %s %d %d unrated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
+        sscanf(line, "%d %s %s %s %d %d unrated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7)  ) {
+	// match: compact and save the line
+	AddAd(handle, rating, base, inc, u ? 'u' : 'r', type, nr, FALSE);
+	return TRUE;
+    }
+    return FALSE;
+}
+
+int
+DrawSeekGraph()
+{
+    if(!seekGraphUp) return FALSE;
+    int i;
+    h = BOARD_HEIGHT * (squareSize + lineGap) + lineGap;
+    w = BOARD_WIDTH  * (squareSize + lineGap) + lineGap;
+
+    DrawSeekBackground(0, 0, w, h);
+    DrawSeekAxis(hMargin, h-1-vMargin, w-5, h-1-vMargin);
+    DrawSeekAxis(hMargin, h-1-vMargin, hMargin, 5);
+    for(i=0; i<4000; i+= 100) if(i>=minRating && i<maxRating) {
+	int yy =((double)i - minRating)/(maxRating - minRating)*(h-vMargin-squareSize/8-1) + vMargin;
+	yy = h-1-yy;
+	DrawSeekAxis(hMargin+5*(i%500==0), yy, hMargin-5, yy); // rating ticks
+	if(i%500 == 0) {
+	    char buf[MSG_SIZ];
+	    sprintf(buf, "%d", i);
+	    DrawSeekText(buf, hMargin+squareSize/8+7, yy);
+	}
+    }
+    DrawSeekText("unrated", hMargin+squareSize/8+7, h-1-vMargin-squareSize/4);
+    for(i=1; i<100; i+=(i<10?1:5)) {
+	int xx = (w-hMargin)* log((double)i)/log(100.) + hMargin;
+	DrawSeekAxis(xx, h-1-vMargin, xx, h-6-vMargin-3*(i%10==0)); // TC ticks
+	if(i<=5 || (i>40 ? i%20 : i%10) == 0) {
+	    char buf[MSG_SIZ];
+	    sprintf(buf, "%d", i);
+	    DrawSeekText(buf, xx-2-3*(i>9), h-1-vMargin/2);
+	}
+    }
+    for(i=0; i<nrOfSeekAds; i++) PlotSeekAd(i);
+    return TRUE;
+}
+
+int SeekGraphClick(ClickType click, int x, int y, int moving)
+{
+    static int lastDown = 0, displayed = 0, lastSecond;
+    if(!seekGraphUp) { // initiate cration of seek graph by requesting seek-ad list
+	if(click == Release || moving) return FALSE;
+	nrOfSeekAds = 0;
+	soughtPending = TRUE;
+	SendToICS(ics_prefix);
+	SendToICS("sought\n"); // should this be "sought all"?
+    } else { // issue challenge based on clicked ad
+	int dist = 10000; int i, closest = 0, second = 0;
+	for(i=0; i<nrOfSeekAds; i++) {
+	    int d = (x-xList[i])*(x-xList[i]) +  (y-yList[i])*(y-yList[i]) + zList[i];
+	    if(d < dist) { dist = d; closest = i; }
+	    second += (d - zList[i] < 120); // count in-range ads
+	    if(click == Press && moving != 1 && zList[i]>0) zList[i] *= 0.8; // age priority
+	}
+	if(dist < 120) {
+	    char buf[MSG_SIZ];
+	    second = (second > 1);
+	    if(displayed != closest || second != lastSecond) {
+		DisplayMessage(second ? "!" : "", seekAdList[closest]);
+		lastSecond = second; displayed = closest;
+	    }
+	    sprintf(buf, "play %d\n", seekNrList[closest]);
+	    if(click == Press) {
+		if(moving == 2) zList[closest] = 100; // right-click; push to back on press
+		lastDown = closest;
+		return TRUE;
+	    } // on press 'hit', only show info
+	    if(moving == 2) return TRUE; // ignore right up-clicks on dot
+	    SendToICS(ics_prefix);
+	    SendToICS(buf); // should this be "sought all"?
+	} else if(click == Release) { // release 'miss' is ignored
+	    zList[lastDown] = 100; // make future selection of the rejected ad more difficult
+	    if(moving == 2) { // right up-click
+		nrOfSeekAds = 0; // refresh graph
+		soughtPending = TRUE;
+		SendToICS(ics_prefix);
+		SendToICS("sought\n"); // should this be "sought all"?
+	    }
+	    return TRUE;
+	} else if(moving) { if(displayed >= 0) DisplayMessage("", ""); displayed = -1; return TRUE; }
+	// press miss or release hit 'pop down' seek graph
+	seekGraphUp = FALSE;
+	DrawPosition(TRUE, NULL);
+    }
+    return TRUE;
+}
+
 void
 read_from_ics(isr, closure, data, count, error)
      InputSourceRef isr;
@@ -2085,6 +2298,8 @@ read_from_ics(isr, closure, data, count, error)
     char talker[MSG_SIZ]; // [HGM] chat
     int channel;
 
+    connectionAlive = TRUE; // [HGM] alive: I think, therefore I am...
+
     if (appData.debugMode) {
       if (!error) {
 	fprintf(debugFP, "<ICS: ");
@@ -2294,12 +2509,16 @@ read_from_ics(isr, closure, data, count, error)
 		  sprintf(str,
 			  "/set-quietly interface %s\n/set-quietly style 12\n",
 			  programVersion);
+		  if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
+		      strcat(str, "/set-2 51 1\n/set seek 1\n");
 		} else if (ics_type == ICS_CHESSNET) {
 		  sprintf(str, "/style 12\n");
 		} else {
 		  strcpy(str, "alias $ @\n$set interface ");
 		  strcat(str, programVersion);
 		  strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
+		  if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
+		      strcat(str, "$iset seekremove 1\n$set seek 1\n");
 #ifdef WIN32
 		  strcat(str, "$iset nohighlight 1\n");
 #endif
@@ -2421,6 +2640,45 @@ read_from_ics(isr, closure, data, count, error)
 	      continue;
 	    }
 
+	    // [HGM] seekgraph: recognize sought lines and end-of-sought message
+	    if(appData.seekGraph) {
+		if(soughtPending && MatchSoughtLine(buf+i)) {
+		    i = strstr(buf+i, "rated") - buf;
+		    next_out = leftover_start = i;
+		    started = STARTED_CHATTER;
+		    suppressKibitz = TRUE;
+		    continue;
+		}
+		if((gameMode == IcsIdle || gameMode == BeginningOfGame)
+			&& looking_at(buf, &i, "* ads displayed")) {
+		    soughtPending = FALSE;
+		    seekGraphUp = TRUE;
+		    DrawSeekGraph();
+		    continue;
+		}
+		if(appData.autoRefresh) {
+		    if(looking_at(buf, &i, "* (*) seeking * * * * *\"play *\" to respond)\n")) {
+			int s = (ics_type == ICS_ICC); // ICC format differs
+			if(seekGraphUp)
+			AddAd(star_match[0], star_match[1], atoi(star_match[2+s]), atoi(star_match[3+s]), 
+			      star_match[4+s][0], star_match[5-3*s], atoi(star_match[7]), TRUE);
+			looking_at(buf, &i, "*% "); // eat prompt
+			next_out = i; // suppress
+			continue;
+		    }
+		    if(looking_at(buf, &i, "Ads removed: *\n") || looking_at(buf, &i, "\031(51 * *\031)")) {
+			char *p = star_match[0];
+			while(*p) {
+			    if(seekGraphUp) RemoveSeekAd(atoi(p));
+			    while(*p && *p++ != ' '); // next
+			}
+			looking_at(buf, &i, "*% "); // eat prompt
+			next_out = i;
+			continue;
+		    }
+		}
+	    }
+
 	    /* skip formula vars */
 	    if (started == STARTED_NONE &&
 		buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
@@ -2454,6 +2712,8 @@ read_from_ics(isr, closure, data, count, error)
 		} else
 		if(looking_at(buf, &i, "kibitzed to *\n") && atoi(star_match[0])) {
 		    // suppress the acknowledgements of our own autoKibitz
+		    char *p;
+		    if(p = strchr(star_match[0], ' ')) p[1] = NULLCHAR; // clip off "players)" on FICS
 		    SendToPlayer(star_match[0], strlen(star_match[0]));
 		    looking_at(buf, &i, "*% "); // eat prompt
 		    next_out = i;
@@ -2475,14 +2735,14 @@ read_from_ics(isr, closure, data, count, error)
 		if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
 		for(p=0; p<MAX_CHAT; p++) {
 		    if(channel == atoi(chatPartner[p])) {
-		    talker[0] = '['; strcat(talker, "]");
+		    talker[0] = '['; strcat(talker, "] ");
 		    chattingPartner = p; break;
 		    }
 		} else
 		if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
 		for(p=0; p<MAX_CHAT; p++) {
 		    if(!strcmp("WHISPER", chatPartner[p])) {
-			talker[0] = '['; strcat(talker, "]");
+			talker[0] = '['; strcat(talker, "] ");
 			chattingPartner = p; break;
 		    }
 		}
@@ -2494,7 +2754,7 @@ read_from_ics(isr, closure, data, count, error)
 		if(chattingPartner<0) i = oldi; else {
 		    started = STARTED_COMMENT;
 		    parse_pos = 0; parse[0] = NULLCHAR;
-		    savingComment = TRUE;
+		    savingComment = 3 + chattingPartner; // counts as TRUE
 		    suppressKibitz = TRUE;
 		}
 	    } // [HGM] chat: end of patch
@@ -2689,6 +2949,8 @@ read_from_ics(isr, closure, data, count, error)
 		    memcpy(parse, &buf[oldi], parse_pos);
 		    parse[parse_pos] = NULLCHAR;
 		    started = STARTED_COMMENT;
+		    if(savingComment >= 3) // [HGM] chat: continuation of line for chat box
+		        chattingPartner = savingComment - 3; // kludge to remember the box
 		} else {
 		    started = STARTED_CHATTER;
 		}
@@ -2856,6 +3118,11 @@ read_from_ics(isr, closure, data, count, error)
 	    if (looking_at(buf, &i, "% ") ||
 		((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
 		 && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
+		if(ics_type == ICS_ICC && soughtPending) { // [HGM] seekgraph: on ICC sought-list has no termination line
+		    soughtPending = FALSE;
+		    seekGraphUp = TRUE;
+		    DrawSeekGraph();
+		}
 		if(suppressKibitz) next_out = i;
 		savingComment = FALSE;
 		suppressKibitz = 0;
@@ -3155,6 +3422,7 @@ read_from_ics(isr, closure, data, count, error)
 		    strncmp(why, "Continuing ", 11) == 0) {
 		    gs_gamenum = gamenum;
 		    strcpy(gs_kind, strchr(why, ' ') + 1);
+		    VariantSwitch(boards[currentMove], StringToVariant(gs_kind)); // [HGM] variantswitch: even before we get first board
 #if ZIPPY
 		    if (appData.zippyPlay) {
 			ZippyGameStart(whitename, blackname);
@@ -3704,16 +3972,16 @@ ParseBoard12(string)
     if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
     { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
 
-        for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
+        for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
             if(board[0][i] == WhiteRook) j = i;
         initialRights[0] = boards[moveNum][CASTLING][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
-        for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
+        for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
             if(board[0][i] == WhiteRook) j = i;
         initialRights[1] = boards[moveNum][CASTLING][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
-        for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
+        for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
         initialRights[3] = boards[moveNum][CASTLING][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
-        for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
+        for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
         initialRights[4] = boards[moveNum][CASTLING][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
 
@@ -3723,6 +3991,11 @@ ParseBoard12(string)
         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
             if(board[BOARD_HEIGHT-1][k] == bKing)
                 initialRights[5] = boards[moveNum][CASTLING][5] = k;
+        if(gameInfo.variant == VariantTwoKings) {
+            // In TwoKings looking for a King does not work, so always give castling rights to a King on e1/e8
+            if(board[0][4] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = 4;
+            if(board[BOARD_HEIGHT-1][4] == bKing) initialRights[5] = boards[moveNum][CASTLING][5] = 4;
+        }
     } else { int r;
         r = boards[moveNum][CASTLING][0] = initialRights[0];
         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][0] = NoRights;
@@ -4011,7 +4284,7 @@ ParseBoard12(string)
   }
     }
 
-   
+
     /* Display the board */
     if (!pausing && !appData.noGUI) {
       
@@ -4021,7 +4294,9 @@ ParseBoard12(string)
 	     ((gameMode == IcsPlayingBlack) && (!WhiteOnMove(currentMove))))
 	      ClearPremoveHighlights();
 
-      DrawPosition(FALSE, boards[currentMove]);
+      j = seekGraphUp; seekGraphUp = FALSE; // [HGM] seekgraph: when we draw a board, it overwrites the seek graph
+      DrawPosition(j, boards[currentMove]);
+
       DisplayMove(moveNum - 1);
       if (appData.ringBellAfterMoves && /*!ics_user_moved*/ // [HGM] use absolute method to recognize own move
 	    !((gameMode == IcsPlayingWhite) && (!WhiteOnMove(moveNum)) ||
@@ -4193,7 +4468,7 @@ SendMoveToICS(moveType, fromX, fromY, toX, toY)
       case BlackPromotionChancellor:
       case WhitePromotionArchbishop:
       case BlackPromotionArchbishop:
-        if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier)
+        if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk)
             sprintf(user_move, "%c%c%c%c=%c\n",
                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
 		PieceToChar(WhiteFerz));
@@ -4781,6 +5056,12 @@ InitPosition(redraw)
       nrCastlingRights = 0;
       SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k"); 
       break;
+    case VariantMakruk:
+      pieces = makrukArray;
+      nrCastlingRights = 0;
+      startedFromSetupPosition = TRUE;
+      SetCharTable(pieceToChar, "PN.R.M....SKpn.r.m....sk"); 
+      break;
     case VariantTwoKings:
       pieces = twoKingsArray;
       break;
@@ -4892,6 +5173,7 @@ InitPosition(redraw)
 
     pawnRow = gameInfo.boardHeight - 7; /* seems to work in all common variants */
     if(pawnRow < 1) pawnRow = 1;
+    if(gameInfo.variant == VariantMakruk) pawnRow = 2;
 
     /* User pieceToChar list overrules defaults */
     if(appData.pieceToCharTable != NULL)
@@ -5056,6 +5338,8 @@ SendBoard(cps, moveNum)
     setboardSpoiledMachineBlack = 0; /* [HGM] assume WB 4.2.7 already solves this after sending setboard */
 }
 
+static int autoQueen; // [HGM] oneclick
+
 int
 HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice)
 {
@@ -5077,6 +5361,8 @@ HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice)
     if(gameInfo.variant == VariantShogi) {
         promotionZoneSize = 3;
         highestPromotingPiece = (int)WhiteFerz;
+    } else if(gameInfo.variant == VariantMakruk) {
+        promotionZoneSize = 3;
     }
 
     // next weed out all moves that do not touch the promotion zone at all
@@ -5120,11 +5406,11 @@ HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice)
     }
 
     // we either have a choice what to promote to, or (in Shogi) whether to promote
-    if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier) {
+    if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk) {
 	*promoChoice = PieceToChar(BlackFerz);  // no choice
 	return FALSE;
     }
-    if(appData.alwaysPromoteToQueen) { // predetermined
+    if(autoQueen) { // predetermined
 	if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantLosers)
 	     *promoChoice = PieceToChar(BlackKing); // in Suicide Q is the last thing we want
 	else *promoChoice = PieceToChar(BlackQueen);
@@ -5265,6 +5551,64 @@ OKToStartUserMove(x, y)
     return TRUE;
 }
 
+Boolean
+OnlyMove(int *x, int *y, Boolean captures) {
+    DisambiguateClosure cl;
+    if (appData.zippyPlay) return FALSE;
+    switch(gameMode) {
+      case MachinePlaysBlack:
+      case IcsPlayingWhite:
+      case BeginningOfGame:
+	if(!WhiteOnMove(currentMove)) return FALSE;
+	break;
+      case MachinePlaysWhite:
+      case IcsPlayingBlack:
+	if(WhiteOnMove(currentMove)) return FALSE;
+	break;
+      default:
+	return FALSE;
+    }
+    cl.pieceIn = EmptySquare; 
+    cl.rfIn = *y;
+    cl.ffIn = *x;
+    cl.rtIn = -1;
+    cl.ftIn = -1;
+    cl.promoCharIn = NULLCHAR;
+    Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
+    if( cl.kind == NormalMove ||
+	cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
+	cl.kind == WhitePromotionQueen || cl.kind == BlackPromotionQueen ||
+	cl.kind == WhitePromotionKnight || cl.kind == BlackPromotionKnight ||
+	cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
+      fromX = cl.ff;
+      fromY = cl.rf;
+      *x = cl.ft;
+      *y = cl.rt;
+      return TRUE;
+    }
+    if(cl.kind != ImpossibleMove) return FALSE;
+    cl.pieceIn = EmptySquare;
+    cl.rfIn = -1;
+    cl.ffIn = -1;
+    cl.rtIn = *y;
+    cl.ftIn = *x;
+    cl.promoCharIn = NULLCHAR;
+    Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
+    if( cl.kind == NormalMove ||
+	cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
+	cl.kind == WhitePromotionQueen || cl.kind == BlackPromotionQueen ||
+	cl.kind == WhitePromotionKnight || cl.kind == BlackPromotionKnight ||
+	cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
+      fromX = cl.ff;
+      fromY = cl.rf;
+      *x = cl.ft;
+      *y = cl.rt;
+      autoQueen = TRUE; // act as if autoQueen on when we click to-square
+      return TRUE;
+    }
+    return FALSE;
+}
+
 FILE *lastLoadGameFP = NULL, *lastLoadPositionFP = NULL;
 int lastLoadGameNumber = 0, lastLoadPositionNumber = 0;
 int lastLoadGameUseList = FALSE;
@@ -5429,8 +5773,6 @@ UserMoveTest(fromX, fromY, toX, toY, promoChar, captureOwn)
          return WhiteDrop; /* Not needed to specify white or black yet */
     }
 
-    userOfferedDraw = FALSE;
-	
     /* [HGM] always test for legality, to get promotion info */
     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
                                          fromY, fromX, toY, toX, promoChar);
@@ -5545,6 +5887,8 @@ FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
 
   MakeMove(fromX, fromY, toX, toY, promoChar); /*updates forwardMostMove*/
 
+  if(Adjudicate(NULL)) return 1; // [HGM] adjudicate: take care of automtic game end
+
   if (gameMode == BeginningOfGame) {
     if (appData.noChessProgram) {
       gameMode = EditGame;
@@ -5569,6 +5913,12 @@ FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
   if (appData.icsActive) {
     if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
 	gameMode == IcsExamining) {
+      if(userOfferedDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
+        SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
+	SendToICS("draw ");
+        SendMoveToICS(moveType, fromX, fromY, toX, toY);
+      }
+      // also send plain move, in case ICS does not understand atomic claims
       SendMoveToICS(moveType, fromX, fromY, toX, toY);
       ics_user_moved = 1;
     }
@@ -5620,6 +5970,8 @@ FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
     break;
   }
 
+  userOfferedDraw = FALSE; // [HGM] drawclaim: after move made, and tested for claimable draw
+	
   if(bookHit) { // [HGM] book: simulate book reply
 	static char bookMove[MSG_SIZ]; // a bit generous?
 
@@ -5700,6 +6052,12 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
     static int second = 0, promotionChoice = 0;
     char promoChoice = NULLCHAR;
 
+    if(appData.seekGraph && appData.icsActive && loggedOn &&
+	(gameMode == BeginningOfGame || gameMode == IcsIdle)) {
+	SeekGraphClick(clickType, xPix, yPix, 0);
+	return;
+    }
+
     if (clickType == Press) ErrorPopDown();
     MarkTargetSquares(1);
 
@@ -5740,7 +6098,10 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
               || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
 	return;
 
+    autoQueen = appData.alwaysPromoteToQueen;
+
     if (fromX == -1) {
+      if(!appData.oneClick || !OnlyMove(&x, &y, FALSE)) {
 	if (clickType == Press) {
 	    /* First square */
 	    if (OKToStartUserMove(x, y)) {
@@ -5755,6 +6116,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 	    }
 	}
 	return;
+      }
     }
 
     /* fromX != -1 */
@@ -5780,6 +6142,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 	     !(fromP == BlackKing && toP == BlackRook && frc))) {
 	    /* Clicked again on same color piece -- changed his mind */
 	    second = (x == fromX && y == fromY);
+	   if(!second || !OnlyMove(&x, &y, TRUE)) {
 	    if (appData.highlightDragging) {
 		SetHighlights(x, y, -1, -1);
 	    } else {
@@ -5792,6 +6155,7 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 		DragPieceBegin(xPix, yPix);
 	    }
 	    return;
+	   }
 	}
 	// ignore clicks on holdings
 	if(x < BOARD_LEFT || x >= BOARD_RGHT) return;
@@ -5850,13 +6214,13 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
 	     
 	    if(x == BOARD_LEFT-2 && piece >= BlackPawn) {
 		n = PieceToNumber(piece - (int)BlackPawn);
-		if(n > gameInfo.holdingsSize) { n = 0; piece = BlackPawn; }
+		if(n >= gameInfo.holdingsSize) { n = 0; piece = BlackPawn; }
 		boards[currentMove][BOARD_HEIGHT-1 - n][0] = piece;
 		boards[currentMove][BOARD_HEIGHT-1 - n][1]++;
 	    } else
 	    if(x == BOARD_RGHT+1 && piece < BlackPawn) {
 		n = PieceToNumber(piece);
-		if(n > gameInfo.holdingsSize) { n = 0; piece = WhitePawn; }
+		if(n >= gameInfo.holdingsSize) { n = 0; piece = WhitePawn; }
 		boards[currentMove][n][BOARD_WIDTH-1] = piece;
 		boards[currentMove][n][BOARD_WIDTH-2]++;
 	    }
@@ -5900,6 +6264,69 @@ void LeftClick(ClickType clickType, int xPix, int yPix)
     }
 }
 
+int RightClick(ClickType action, int x, int y, int *fromX, int *fromY)
+{   // front-end-free part taken out of PieceMenuPopup
+    int whichMenu; int xSqr, ySqr;
+
+    if(seekGraphUp) { // [HGM] seekgraph
+	if(action == Press)   SeekGraphClick(Press, x, y, 2); // 2 indicates right-click: no pop-down on miss
+	if(action == Release) SeekGraphClick(Release, x, y, 2); // and no challenge on hit
+	return -2;
+    }
+
+    xSqr = EventToSquare(x, BOARD_WIDTH);
+    ySqr = EventToSquare(y, BOARD_HEIGHT);
+    if (action == Release) UnLoadPV(); // [HGM] pv
+    if (action != Press) return -2; // return code to be ignored
+    switch (gameMode) {
+      case IcsExamining:
+	if(xSqr < BOARD_LEFT || xSqr >= BOARD_RGHT) return -1;
+      case EditPosition:
+	if (xSqr == BOARD_LEFT-1 || xSqr == BOARD_RGHT) return -1;
+	if (xSqr < 0 || ySqr < 0) return -1;
+	whichMenu = 0; // edit-position menu
+	break;
+      case IcsObserving:
+	if(!appData.icsEngineAnalyze) return -1;
+      case IcsPlayingWhite:
+      case IcsPlayingBlack:
+	if(!appData.zippyPlay) goto noZip;
+      case AnalyzeMode:
+      case AnalyzeFile:
+      case MachinePlaysWhite:
+      case MachinePlaysBlack:
+      case TwoMachinesPlay: // [HGM] pv: use for showing PV
+	if (!appData.dropMenu) {
+	  LoadPV(x, y);
+	  return 2; // flag front-end to grab mouse events
+	}
+	if(gameMode == TwoMachinesPlay || gameMode == AnalyzeMode ||
+           gameMode == AnalyzeFile || gameMode == IcsObserving) return -1;
+      case EditGame:
+      noZip:
+	if (xSqr < 0 || ySqr < 0) return -1;
+	if (!appData.dropMenu || appData.testLegality &&
+	    gameInfo.variant != VariantBughouse &&
+	    gameInfo.variant != VariantCrazyhouse) return -1;
+	whichMenu = 1; // drop menu
+	break;
+      default:
+	return -1;
+    }
+
+    if (((*fromX = xSqr) < 0) ||
+	((*fromY = ySqr) < 0)) {
+	*fromX = *fromY = -1;
+	return -1;
+    }
+    if (flipView)
+      *fromX = BOARD_WIDTH - 1 - *fromX;
+    else
+      *fromY = BOARD_HEIGHT - 1 - *fromY;
+
+    return whichMenu;
+}
+
 void SendProgramStatsToFrontend( ChessProgramState * cps, ChessProgramStats * cpstats )
 {
 //    char * hint = lastHint;
@@ -5926,308 +6353,19 @@ void SendProgramStatsToFrontend( ChessProgramState * cps, ChessProgramStats * cp
     SetProgramStats( &stats );
 }
 
-char *SendMoveToBookUser(int moveNr, ChessProgramState *cps, int initial)
-{   // [HGM] book: this routine intercepts moves to simulate book replies
-    char *bookHit = NULL;
-
-    //first determine if the incoming move brings opponent into his book
-    if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
-	bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
-    if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
-    if(bookHit != NULL && !cps->bookSuspend) {
-	// make sure opponent is not going to reply after receiving move to book position
-	SendToProgram("force\n", cps);
-	cps->bookSuspend = TRUE; // flag indicating it has to be restarted
-    }
-    if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
-    // now arrange restart after book miss
-    if(bookHit) {
-	// after a book hit we never send 'go', and the code after the call to this routine
-	// has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
-	char buf[MSG_SIZ];
-	if (cps->useUsermove) sprintf(buf, "usermove "); // sorry, no SAN yet :(
-	sprintf(buf, "%s\n", bookHit); // force book move into program supposed to play it
-	SendToProgram(buf, cps);
-	if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
-    } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
-	SendToProgram("go\n", cps);
-	cps->bookSuspend = FALSE; // after a 'go' we are never suspended
-    } else { // 'go' might be sent based on 'firstMove' after this routine returns
-	if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
-	    SendToProgram("go\n", cps); 
-	cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
-    }
-    return bookHit; // notify caller of hit, so it can take action to send move to opponent
-}
-
-char *savedMessage;
-ChessProgramState *savedState;
-void DeferredBookMove(void)
-{
-	if(savedState->lastPing != savedState->lastPong)
-		    ScheduleDelayedEvent(DeferredBookMove, 10);
-	else
-	HandleMachineMove(savedMessage, savedState);
-}
-
-void
-HandleMachineMove(message, cps)
-     char *message;
-     ChessProgramState *cps;
-{
-    char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
-    char realname[MSG_SIZ];
-    int fromX, fromY, toX, toY;
-    ChessMove moveType;
-    char promoChar;
-    char *p;
-    int machineWhite;
-    char *bookHit;
-
-    cps->userError = 0;
-
-FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
-    /*
-     * Kludge to ignore BEL characters
-     */
-    while (*message == '\007') message++;
-
-    /*
-     * [HGM] engine debug message: ignore lines starting with '#' character
-     */
-    if(cps->debug && *message == '#') return;
-
-    /*
-     * Look for book output
-     */
-    if (cps == &first && bookRequested) {
-	if (message[0] == '\t' || message[0] == ' ') {
-	    /* Part of the book output is here; append it */
-	    strcat(bookOutput, message);
-	    strcat(bookOutput, "  \n");
-	    return;
-	} else if (bookOutput[0] != NULLCHAR) {
-	    /* All of book output has arrived; display it */
-	    char *p = bookOutput;
-	    while (*p != NULLCHAR) {
-		if (*p == '\t') *p = ' ';
-		p++;
-	    }
-	    DisplayInformation(bookOutput);
-	    bookRequested = FALSE;
-	    /* Fall through to parse the current output */
-	}
-    }
-
-    /*
-     * Look for machine move.
-     */
-    if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
-	(sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0)) 
-    {
-        /* This method is only useful on engines that support ping */
-        if (cps->lastPing != cps->lastPong) {
-	  if (gameMode == BeginningOfGame) {
-	    /* Extra move from before last new; ignore */
-	    if (appData.debugMode) {
-		fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
-	    }
-	  } else {
-	    if (appData.debugMode) {
-		fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
-			cps->which, gameMode);
-	    }
-
-            SendToProgram("undo\n", cps);
-	  }
-	  return;
-	}
-
-	switch (gameMode) {
-	  case BeginningOfGame:
-	    /* Extra move from before last reset; ignore */
-	    if (appData.debugMode) {
-		fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
-	    }
-	    return;
-
-	  case EndOfGame:
-	  case IcsIdle:
-	  default:
-	    /* Extra move after we tried to stop.  The mode test is
-	       not a reliable way of detecting this problem, but it's
-	       the best we can do on engines that don't support ping.
-	    */
-	    if (appData.debugMode) {
-		fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
-			cps->which, gameMode);
-	    }
-	    SendToProgram("undo\n", cps);
-	    return;
-
-	  case MachinePlaysWhite:
-	  case IcsPlayingWhite:
-	    machineWhite = TRUE;
-	    break;
-
-	  case MachinePlaysBlack:
-	  case IcsPlayingBlack:
-	    machineWhite = FALSE;
-	    break;
-
-	  case TwoMachinesPlay:
-	    machineWhite = (cps->twoMachinesColor[0] == 'w');
-	    break;
-	}
-	if (WhiteOnMove(forwardMostMove) != machineWhite) {
-	    if (appData.debugMode) {
-		fprintf(debugFP,
-			"Ignoring move out of turn by %s, gameMode %d"
-			", forwardMost %d\n",
-			cps->which, gameMode, forwardMostMove);
-	    }
-	    return;
-	}
-
-    if (appData.debugMode) { int f = forwardMostMove;
-        fprintf(debugFP, "machine move %d, castling = %d %d %d %d %d %d\n", f,
-                boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
-                boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
-    }
-        if(cps->alphaRank) AlphaRank(machineMove, 4);
-        if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
-                              &fromX, &fromY, &toX, &toY, &promoChar)) {
-	    /* Machine move could not be parsed; ignore it. */
-            sprintf(buf1, _("Illegal move \"%s\" from %s machine"),
-		    machineMove, cps->which);
-	    DisplayError(buf1, 0);
-            sprintf(buf1, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c) res=%d",
-                    machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, moveType);
-	    if (gameMode == TwoMachinesPlay) {
-	      GameEnds(machineWhite ? BlackWins : WhiteWins,
-                       buf1, GE_XBOARD);
-	    }
-	    return;
-	}
-
-        /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
-        /* So we have to redo legality test with true e.p. status here,  */
-        /* to make sure an illegal e.p. capture does not slip through,   */
-        /* to cause a forfeit on a justified illegal-move complaint      */
-        /* of the opponent.                                              */
-        if( gameMode==TwoMachinesPlay && appData.testLegality
-            && fromY != DROP_RANK /* [HGM] temporary; should still add legality test for drops */
-                                                              ) {
-           ChessMove moveType;
-           moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
-                             fromY, fromX, toY, toX, promoChar);
-	    if (appData.debugMode) {
-                int i;
-                for(i=0; i< nrCastlingRights; i++) fprintf(debugFP, "(%d,%d) ",
-                    boards[forwardMostMove][CASTLING][i], castlingRank[i]);
-                fprintf(debugFP, "castling rights\n");
-	    }
-            if(moveType == IllegalMove) {
-                sprintf(buf1, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
-                        machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
-                GameEnds(machineWhite ? BlackWins : WhiteWins,
-                           buf1, GE_XBOARD);
-		return;
-           } else if(gameInfo.variant != VariantFischeRandom && gameInfo.variant != VariantCapaRandom)
-           /* [HGM] Kludge to handle engines that send FRC-style castling
-              when they shouldn't (like TSCP-Gothic) */
-           switch(moveType) {
-             case WhiteASideCastleFR:
-             case BlackASideCastleFR:
-               toX+=2;
-               currentMoveString[2]++;
-               break;
-             case WhiteHSideCastleFR:
-             case BlackHSideCastleFR:
-               toX--;
-               currentMoveString[2]--;
-               break;
-	     default: ; // nothing to do, but suppresses warning of pedantic compilers
-           }
-        }
-	hintRequested = FALSE;
-	lastHint[0] = NULLCHAR;
-	bookRequested = FALSE;
-	/* Program may be pondering now */
-	cps->maybeThinking = TRUE;
-	if (cps->sendTime == 2) cps->sendTime = 1;
-	if (cps->offeredDraw) cps->offeredDraw--;
-
-#if ZIPPY
-	if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
-	    first.initDone) {
-	  SendMoveToICS(moveType, fromX, fromY, toX, toY);
-	  ics_user_moved = 1;
-	  if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
-		char buf[3*MSG_SIZ];
-
-		sprintf(buf, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
-			programStats.score / 100.,
-			programStats.depth,
-			programStats.time / 100.,
-			(unsigned int)programStats.nodes,
-			(unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
-			programStats.movelist);
-		SendToICS(buf);
-if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.nodes, programStats.nodes);
-	  }
-	}
-#endif
-	/* currentMoveString is set as a side-effect of ParseOneMove */
-	strcpy(machineMove, currentMoveString);
-	strcat(machineMove, "\n");
-	strcpy(moveList[forwardMostMove], machineMove);
-
-        /* [AS] Save move info and clear stats for next move */
-        pvInfoList[ forwardMostMove ].score = programStats.score;
-        pvInfoList[ forwardMostMove ].depth = programStats.depth;
-        pvInfoList[ forwardMostMove ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
-        ClearProgramStats();
-        thinkOutput[0] = NULLCHAR;
-        hiddenThinkOutputState = 0;
-
-	MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
-
-        /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
-        if( gameMode == TwoMachinesPlay && adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
-            int count = 0;
-
-            while( count < adjudicateLossPlies ) {
-                int score = pvInfoList[ forwardMostMove - count - 1 ].score;
-
-                if( count & 1 ) {
-                    score = -score; /* Flip score for winning side */
-                }
-
-                if( score > adjudicateLossThreshold ) {
-                    break;
-                }
-
-                count++;
-            }
-
-            if( count >= adjudicateLossPlies ) {
-	        ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
-
-                GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins, 
-                    "Xboard adjudication", 
-                    GE_XBOARD );
-
-                return;
-            }
-        }
-
-	if( gameMode == TwoMachinesPlay ) {
-	  // [HGM] some adjudications useful with buggy engines
-            int k, count = 0; static int bare = 1;
-	  if(gameInfo.holdingsSize == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
-
-
+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
+	//       In any case it determnes if the game is a claimable draw (filling in EP_STATUS).
+	//       Actually ending the game is now based on the additional internal condition canAdjudicate.
+	//       Only when the game is ended, and the opponent is a computer, this opponent gets the move relayed.
+	int k, count = 0; static int bare = 1;
+	ChessProgramState *engineOpponent = (gameMode == TwoMachinesPlay ? cps->other : (cps ? NULL : &first));
+	Boolean canAdjudicate = !appData.icsActive;
+
+	// most tests only when we understand the game, i.e. legality-checking on, and (for the time being) no piece drops
+	if(gameInfo.holdingsSize == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
 	    if( appData.testLegality )
 	    {   /* [HGM] Some more adjudications for obstinate engines */
 		int NrWN=0, NrBN=0, NrWB=0, NrBB=0, NrWR=0, NrBR=0,
@@ -6287,12 +6425,13 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
 		if(gameInfo.variant == VariantAtomic && NrK < 2) {
 		    // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
 		     boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // make claimable as if stm is checkmated
-		     if(appData.checkMates) {
-			 SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets move
+		     if(canAdjudicate && appData.checkMates) {
+			 if(engineOpponent)
+			   SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
                          GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins, 
 							"Xboard adjudication: King destroyed", GE_XBOARD );
-                         return;
+                         return 1;
 		     }
 		}
 
@@ -6300,24 +6439,26 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
                 if( NrW == 1 || NrPieces - NrW == 1) {
                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
 		     boards[forwardMostMove][EP_STATUS] = EP_WINS;  // mark as win, so it becomes claimable
-		     if(appData.checkMates) {
-			 SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets to see move
+		     if(canAdjudicate && appData.checkMates) {
+			 if(engineOpponent)
+			   SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets to see move
                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
                          GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins, 
 							"Xboard adjudication: Bare king", GE_XBOARD );
-                         return;
+                         return 1;
 		     }
 		  } else
                   if( gameInfo.variant == VariantShatranj && --bare < 0)
                   {    /* bare King */
 			boards[forwardMostMove][EP_STATUS] = EP_WINS; // make claimable as win for stm
-			if(appData.checkMates) {
+			if(canAdjudicate && appData.checkMates) {
 			    /* but only adjudicate if adjudication enabled */
-			    SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets move
+			    if(engineOpponent)
+			      SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
 			    ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
 			    GameEnds( NrW > 1 ? WhiteWins : NrPieces - NrW > 1 ? BlackWins : GameIsDrawn, 
 							"Xboard adjudication: Bare king", GE_XBOARD );
-			    return;
+			    return 1;
 			}
 		  }
                 } else bare = 1;
@@ -6372,11 +6513,12 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
 		    default:
 			result = (ChessMove) 0;
 		}
-                if(appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
-		    SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
+                if(canAdjudicate && appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
+		    if(engineOpponent)
+		      SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
 		    ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
 		    GameEnds( result, reason, GE_XBOARD );
-		    return;
+		    return 1;
 		}
 
                 /* Next absolutely insufficient mating material. */
@@ -6389,13 +6531,15 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
                      /* always flag draws, for judging claims */
                      boards[forwardMostMove][EP_STATUS] = EP_INSUF_DRAW;
 
-                     if(appData.materialDraws) {
+                     if(canAdjudicate && appData.materialDraws) {
                          /* but only adjudicate them if adjudication enabled */
-			 SendToProgram("force\n", cps->other); // suppress reply
-			 SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see last move */
+			 if(engineOpponent) {
+			   SendToProgram("force\n", engineOpponent); // suppress reply
+			   SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see last move */
+			 }
                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
                          GameEnds( GameIsDrawn, "Xboard adjudication: Insufficient mating material", GE_XBOARD );
-                         return;
+                         return 1;
                      }
                 }
 
@@ -6406,26 +6550,30 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
                    || NrWN==2 || NrBN==2     /* KNNK */
                    || NrWN+NrWB == 1 && NrBN+NrBB == 1 /* KBKN, KBKB, KNKN */
                   ) ) {
-                     if(--moveCount < 0 && appData.trivialDraws)
+                     if(canAdjudicate && --moveCount < 0 && appData.trivialDraws)
                      {    /* if the first 3 moves do not show a tactical win, declare draw */
-			  SendToProgram("force\n", cps->other); // suppress reply
-			  SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
+			  if(engineOpponent) {
+			    SendToProgram("force\n", engineOpponent); // suppress reply
+			    SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
+			  }
                           ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
                           GameEnds( GameIsDrawn, "Xboard adjudication: Trivial draw", GE_XBOARD );
-                          return;
+                          return 1;
                      }
                 } else moveCount = 6;
 	    }
-	  }
+	}
 	  
-	  if (appData.debugMode) { int i;
+	if (appData.debugMode) { int i;
 	    fprintf(debugFP, "repeat test fmm=%d bmm=%d ep=%d, reps=%d\n",
 		    forwardMostMove, backwardMostMove, boards[backwardMostMove][EP_STATUS],
 		    appData.drawRepeats);
 	    for( i=forwardMostMove; i>=backwardMostMove; i-- )
 	      fprintf(debugFP, "%d ep=%d\n", i, (signed char)boards[i][EP_STATUS]);
 	    
-	  }
+	}
+
+	// Repetition draws and 50-move rule can be applied independently of legality testing
 
                 /* Check for rep-draws */
                 count = 0;
@@ -6453,11 +6601,13 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
                                 boards[forwardMostMove][CASTLING][4] != boards[k][CASTLING][4] )
                                    rights++;
                         }
-                        if( rights == 0 && ++count > appData.drawRepeats-2
+                        if( canAdjudicate && rights == 0 && ++count > appData.drawRepeats-2
                             && appData.drawRepeats > 1) {
                              /* adjudicate after user-specified nr of repeats */
-			     SendToProgram("force\n", cps->other); // suppress reply
-			     SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
+			     if(engineOpponent) {
+			       SendToProgram("force\n", engineOpponent); // suppress reply
+			       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
+			     }
                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
 			     if(gameInfo.variant == VariantXiangqi && appData.testLegality) { 
 				// [HGM] xiangqi: check for forbidden perpetuals
@@ -6473,7 +6623,7 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
 				if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
 				    GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins, 
 		 			   "Xboard adjudication: perpetual checking", GE_XBOARD );
-				    return;
+				    return 1;
 				}
 				if(hisPerpetual && !ourPerpetual)   // he is checking us, but did not repeat yet
 				    break; // (or we would have caught him before). Abort repetition-checking loop.
@@ -6484,7 +6634,7 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
 				    if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
 					GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins, 
 		 				      "Xboard adjudication: perpetual chasing", GE_XBOARD );
-					return;
+					return 1;
 				    }
 				    if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
 					break; // Abort repetition-checking loop.
@@ -6492,7 +6642,7 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
 				// if neither of us is checking or chasing all the time, or both are, it is draw
 			     }
                              GameEnds( GameIsDrawn, "Xboard adjudication: repetition draw", GE_XBOARD );
-                             return;
+                             return 1;
                         }
                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
                              boards[forwardMostMove][EP_STATUS] = EP_REP_DRAW;
@@ -6511,12 +6661,14 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
                 if( count >= 100)
                          boards[forwardMostMove][EP_STATUS] = EP_RULE_DRAW;
                          /* this is used to judge if draw claims are legal */
-                if(appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
-			 SendToProgram("force\n", cps->other); // suppress reply
-			 SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
+                if(canAdjudicate && appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
+			 if(engineOpponent) {
+			   SendToProgram("force\n", engineOpponent); // suppress reply
+			   SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
+			 }
                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
                          GameEnds( GameIsDrawn, "Xboard adjudication: 50-move rule", GE_XBOARD );
-                         return;
+                         return 1;
                 }
 
                 /* if draw offer is pending, treat it as a draw claim
@@ -6524,7 +6676,7 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
                  * claim draws before making their move to avoid a race
                  * condition occurring after their move
                  */
-                if( cps->other->offeredDraw || cps->offeredDraw ) {
+		if((gameMode == TwoMachinesPlay ? second.offeredDraw : userOfferedDraw) || first.offeredDraw ) {
                          char *p = NULL;
                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_RULE_DRAW)
                              p = "Draw claim: 50-move rule";
@@ -6532,27 +6684,333 @@ if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.
                              p = "Draw claim: 3-fold repetition";
                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_INSUF_DRAW)
                              p = "Draw claim: insufficient mating material";
-                         if( p != NULL ) {
-			     SendToProgram("force\n", cps->other); // suppress reply
-			     SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
-                             GameEnds( GameIsDrawn, p, GE_XBOARD );
+                         if( p != NULL && canAdjudicate) {
+			     if(engineOpponent) {
+			       SendToProgram("force\n", engineOpponent); // suppress reply
+			       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
+			     }
                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
-                             return;
+                             GameEnds( GameIsDrawn, p, GE_XBOARD );
+                             return 1;
                          }
                 }
 
-
-	        if( appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
-		    SendToProgram("force\n", cps->other); // suppress reply
-		    SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
+	        if( canAdjudicate && appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
+		    if(engineOpponent) {
+		      SendToProgram("force\n", engineOpponent); // suppress reply
+		      SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
+		    }
 		    ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
-
 	            GameEnds( GameIsDrawn, "Xboard adjudication: long game", GE_XBOARD );
-
-	            return;
+	            return 1;
         	}
+	return 0;
+}
+
+char *SendMoveToBookUser(int moveNr, ChessProgramState *cps, int initial)
+{   // [HGM] book: this routine intercepts moves to simulate book replies
+    char *bookHit = NULL;
+
+    //first determine if the incoming move brings opponent into his book
+    if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
+	bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
+    if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
+    if(bookHit != NULL && !cps->bookSuspend) {
+	// make sure opponent is not going to reply after receiving move to book position
+	SendToProgram("force\n", cps);
+	cps->bookSuspend = TRUE; // flag indicating it has to be restarted
+    }
+    if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
+    // now arrange restart after book miss
+    if(bookHit) {
+	// after a book hit we never send 'go', and the code after the call to this routine
+	// has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
+	char buf[MSG_SIZ];
+	if (cps->useUsermove) sprintf(buf, "usermove "); // sorry, no SAN yet :(
+	sprintf(buf, "%s\n", bookHit); // force book move into program supposed to play it
+	SendToProgram(buf, cps);
+	if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
+    } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
+	SendToProgram("go\n", cps);
+	cps->bookSuspend = FALSE; // after a 'go' we are never suspended
+    } else { // 'go' might be sent based on 'firstMove' after this routine returns
+	if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
+	    SendToProgram("go\n", cps); 
+	cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
+    }
+    return bookHit; // notify caller of hit, so it can take action to send move to opponent
+}
+
+char *savedMessage;
+ChessProgramState *savedState;
+void DeferredBookMove(void)
+{
+	if(savedState->lastPing != savedState->lastPong)
+		    ScheduleDelayedEvent(DeferredBookMove, 10);
+	else
+	HandleMachineMove(savedMessage, savedState);
+}
+
+void
+HandleMachineMove(message, cps)
+     char *message;
+     ChessProgramState *cps;
+{
+    char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
+    char realname[MSG_SIZ];
+    int fromX, fromY, toX, toY;
+    ChessMove moveType;
+    char promoChar;
+    char *p;
+    int machineWhite;
+    char *bookHit;
+
+    cps->userError = 0;
+
+FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
+    /*
+     * Kludge to ignore BEL characters
+     */
+    while (*message == '\007') message++;
+
+    /*
+     * [HGM] engine debug message: ignore lines starting with '#' character
+     */
+    if(cps->debug && *message == '#') return;
+
+    /*
+     * Look for book output
+     */
+    if (cps == &first && bookRequested) {
+	if (message[0] == '\t' || message[0] == ' ') {
+	    /* Part of the book output is here; append it */
+	    strcat(bookOutput, message);
+	    strcat(bookOutput, "  \n");
+	    return;
+	} else if (bookOutput[0] != NULLCHAR) {
+	    /* All of book output has arrived; display it */
+	    char *p = bookOutput;
+	    while (*p != NULLCHAR) {
+		if (*p == '\t') *p = ' ';
+		p++;
+	    }
+	    DisplayInformation(bookOutput);
+	    bookRequested = FALSE;
+	    /* Fall through to parse the current output */
+	}
+    }
+
+    /*
+     * Look for machine move.
+     */
+    if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
+	(sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0)) 
+    {
+        /* This method is only useful on engines that support ping */
+        if (cps->lastPing != cps->lastPong) {
+	  if (gameMode == BeginningOfGame) {
+	    /* Extra move from before last new; ignore */
+	    if (appData.debugMode) {
+		fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
+	    }
+	  } else {
+	    if (appData.debugMode) {
+		fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
+			cps->which, gameMode);
+	    }
+
+            SendToProgram("undo\n", cps);
+	  }
+	  return;
+	}
+
+	switch (gameMode) {
+	  case BeginningOfGame:
+	    /* Extra move from before last reset; ignore */
+	    if (appData.debugMode) {
+		fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
+	    }
+	    return;
+
+	  case EndOfGame:
+	  case IcsIdle:
+	  default:
+	    /* Extra move after we tried to stop.  The mode test is
+	       not a reliable way of detecting this problem, but it's
+	       the best we can do on engines that don't support ping.
+	    */
+	    if (appData.debugMode) {
+		fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
+			cps->which, gameMode);
+	    }
+	    SendToProgram("undo\n", cps);
+	    return;
+
+	  case MachinePlaysWhite:
+	  case IcsPlayingWhite:
+	    machineWhite = TRUE;
+	    break;
+
+	  case MachinePlaysBlack:
+	  case IcsPlayingBlack:
+	    machineWhite = FALSE;
+	    break;
+
+	  case TwoMachinesPlay:
+	    machineWhite = (cps->twoMachinesColor[0] == 'w');
+	    break;
+	}
+	if (WhiteOnMove(forwardMostMove) != machineWhite) {
+	    if (appData.debugMode) {
+		fprintf(debugFP,
+			"Ignoring move out of turn by %s, gameMode %d"
+			", forwardMost %d\n",
+			cps->which, gameMode, forwardMostMove);
+	    }
+	    return;
+	}
+
+    if (appData.debugMode) { int f = forwardMostMove;
+        fprintf(debugFP, "machine move %d, castling = %d %d %d %d %d %d\n", f,
+                boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
+                boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
+    }
+        if(cps->alphaRank) AlphaRank(machineMove, 4);
+        if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
+                              &fromX, &fromY, &toX, &toY, &promoChar)) {
+	    /* Machine move could not be parsed; ignore it. */
+            sprintf(buf1, _("Illegal move \"%s\" from %s machine"),
+		    machineMove, cps->which);
+	    DisplayError(buf1, 0);
+            sprintf(buf1, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c) res=%d",
+                    machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, moveType);
+	    if (gameMode == TwoMachinesPlay) {
+	      GameEnds(machineWhite ? BlackWins : WhiteWins,
+                       buf1, GE_XBOARD);
+	    }
+	    return;
+	}
+
+        /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
+        /* So we have to redo legality test with true e.p. status here,  */
+        /* to make sure an illegal e.p. capture does not slip through,   */
+        /* to cause a forfeit on a justified illegal-move complaint      */
+        /* of the opponent.                                              */
+        if( gameMode==TwoMachinesPlay && appData.testLegality
+            && fromY != DROP_RANK /* [HGM] temporary; should still add legality test for drops */
+                                                              ) {
+           ChessMove moveType;
+           moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
+                             fromY, fromX, toY, toX, promoChar);
+	    if (appData.debugMode) {
+                int i;
+                for(i=0; i< nrCastlingRights; i++) fprintf(debugFP, "(%d,%d) ",
+                    boards[forwardMostMove][CASTLING][i], castlingRank[i]);
+                fprintf(debugFP, "castling rights\n");
+	    }
+            if(moveType == IllegalMove) {
+                sprintf(buf1, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
+                        machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
+                GameEnds(machineWhite ? BlackWins : WhiteWins,
+                           buf1, GE_XBOARD);
+		return;
+           } else if(gameInfo.variant != VariantFischeRandom && gameInfo.variant != VariantCapaRandom)
+           /* [HGM] Kludge to handle engines that send FRC-style castling
+              when they shouldn't (like TSCP-Gothic) */
+           switch(moveType) {
+             case WhiteASideCastleFR:
+             case BlackASideCastleFR:
+               toX+=2;
+               currentMoveString[2]++;
+               break;
+             case WhiteHSideCastleFR:
+             case BlackHSideCastleFR:
+               toX--;
+               currentMoveString[2]--;
+               break;
+	     default: ; // nothing to do, but suppresses warning of pedantic compilers
+           }
+        }
+	hintRequested = FALSE;
+	lastHint[0] = NULLCHAR;
+	bookRequested = FALSE;
+	/* Program may be pondering now */
+	cps->maybeThinking = TRUE;
+	if (cps->sendTime == 2) cps->sendTime = 1;
+	if (cps->offeredDraw) cps->offeredDraw--;
+
+	/* currentMoveString is set as a side-effect of ParseOneMove */
+	strcpy(machineMove, currentMoveString);
+	strcat(machineMove, "\n");
+	strcpy(moveList[forwardMostMove], machineMove);
+
+	MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
+
+        /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
+        if( gameMode == TwoMachinesPlay && adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
+            int count = 0;
+
+            while( count < adjudicateLossPlies ) {
+                int score = pvInfoList[ forwardMostMove - count - 1 ].score;
+
+                if( count & 1 ) {
+                    score = -score; /* Flip score for winning side */
+                }
+
+                if( score > adjudicateLossThreshold ) {
+                    break;
+                }
+
+                count++;
+            }
+
+            if( count >= adjudicateLossPlies ) {
+	        ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
+
+                GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins, 
+                    "Xboard adjudication", 
+                    GE_XBOARD );
+
+                return;
+            }
         }
 
+	if(Adjudicate(cps)) return; // [HGM] adjudicate: for all automatic game ends
+
+#if ZIPPY
+	if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
+	    first.initDone) {
+	  if(cps->offeredDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
+		SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
+		SendToICS("draw ");
+		SendMoveToICS(moveType, fromX, fromY, toX, toY);
+	  }
+	  SendMoveToICS(moveType, fromX, fromY, toX, toY);
+	  ics_user_moved = 1;
+	  if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
+		char buf[3*MSG_SIZ];
+
+		sprintf(buf, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
+			programStats.score / 100.,
+			programStats.depth,
+			programStats.time / 100.,
+			(unsigned int)programStats.nodes,
+			(unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
+			programStats.movelist);
+		SendToICS(buf);
+if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.nodes, programStats.nodes);
+	  }
+	}
+#endif
+
+        /* [AS] Save move info and clear stats for next move */
+        pvInfoList[ forwardMostMove-1 ].score = programStats.score;
+        pvInfoList[ forwardMostMove-1 ].depth = programStats.depth;
+        pvInfoList[ forwardMostMove-1 ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
+        ClearProgramStats();
+        thinkOutput[0] = NULLCHAR;
+        hiddenThinkOutputState = 0;
+
 	bookHit = NULL;
 	if (gameMode == TwoMachinesPlay) {
             /* [HGM] relaying draw offers moved to after reception of move */
@@ -7542,6 +8000,7 @@ ApplyMove(fromX, fromY, toX, toY, promoChar, board)
      Board board;
 {
   ChessSquare captured = board[toY][toX], piece, king; int p, oldEP = EP_NONE, berolina = 0;
+  int promoRank = gameInfo.variant == VariantMakruk ? 3 : 1;
 
     /* [HGM] compute & store e.p. status and castling rights for new position */
     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
@@ -7588,7 +8047,7 @@ ApplyMove(fromX, fromY, toX, toY, promoChar, board)
     }
 
   /* [HGM] In Shatranj and Courier all promotions are to Ferz */
-  if((gameInfo.variant==VariantShatranj || gameInfo.variant==VariantCourier)
+  if((gameInfo.variant==VariantShatranj || gameInfo.variant==VariantCourier || gameInfo.variant == VariantMakruk)
        && promoChar != 0) promoChar = PieceToChar(WhiteFerz);
          
   if (fromX == toX && fromY == toY) return;
@@ -7639,7 +8098,7 @@ ApplyMove(fromX, fromY, toX, toY, promoChar, board)
         board[toY][toX+1] = board[fromY][BOARD_LEFT];
         board[fromY][BOARD_LEFT] = EmptySquare;
     } else if (board[fromY][fromX] == WhitePawn
-               && toY == BOARD_HEIGHT-1
+               && toY >= BOARD_HEIGHT-promoRank
                && gameInfo.variant != VariantXiangqi
                ) {
 	/* white pawn promotion */
@@ -7703,13 +8162,13 @@ ApplyMove(fromX, fromY, toX, toY, promoChar, board)
 	board[fromY][0] = EmptySquare;
 	board[toY][2] = BlackRook;
     } else if (board[fromY][fromX] == BlackPawn
-	       && toY == 0
+	       && toY < promoRank
                && gameInfo.variant != VariantXiangqi
                ) {
 	/* black pawn promotion */
-	board[0][toX] = CharToPiece(ToLower(promoChar));
-	if (board[0][toX] == EmptySquare) {
-	    board[0][toX] = BlackQueen;
+	board[toY][toX] = CharToPiece(ToLower(promoChar));
+	if (board[toY][toX] == EmptySquare) {
+	    board[toY][toX] = BlackQueen;
 	}
         if(gameInfo.variant==VariantBughouse ||
            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
@@ -8262,6 +8721,8 @@ GameEnds(result, resultDetails, whosays)
 	      result, resultDetails ? resultDetails : "(null)", whosays);
     }
 
+    fromX = fromY = -1; // [HGM] abort any move the user is entering.
+
     if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
 	/* If we are playing on ICS, the server decides when the
 	   game is over, but the engine can offer to draw, claim 
@@ -11532,7 +11993,8 @@ EditPositionMenuEvent(selection, x, y)
       case BlackQueen:
         if(gameInfo.variant == VariantShatranj ||
            gameInfo.variant == VariantXiangqi  ||
-           gameInfo.variant == VariantCourier    )
+           gameInfo.variant == VariantCourier  ||
+           gameInfo.variant == VariantMakruk     )
             selection = (ChessSquare)((int)selection - (int)WhiteQueen + (int)WhiteFerz);
         goto defaultlabel;
 
@@ -11554,13 +12016,13 @@ EditPositionMenuEvent(selection, x, y)
                 int n;
                 if(x == BOARD_LEFT-2 && selection >= BlackPawn) {
                     n = PieceToNumber(selection - BlackPawn);
-                    if(n > gameInfo.holdingsSize) { n = 0; selection = BlackPawn; }
+                    if(n >= gameInfo.holdingsSize) { n = 0; selection = BlackPawn; }
                     boards[0][BOARD_HEIGHT-1-n][0] = selection;
                     boards[0][BOARD_HEIGHT-1-n][1]++;
                 } else
                 if(x == BOARD_RGHT+1 && selection < BlackPawn) {
                     n = PieceToNumber(selection);
-                    if(n > gameInfo.holdingsSize) { n = 0; selection = WhitePawn; }
+                    if(n >= gameInfo.holdingsSize) { n = 0; selection = WhitePawn; }
                     boards[0][n][BOARD_WIDTH-1] = selection;
                     boards[0][n][BOARD_WIDTH-2]++;
                 }
@@ -11727,6 +12189,7 @@ DrawEvent()
 	
         SendToICS(ics_prefix);
 	SendToICS("draw\n");
+        userOfferedDraw = TRUE; // [HGM] drawclaim: also set flag in ICS play
     } else if (cmailMsgLoaded) {
 	if (currentMove == cmailOldMove &&
 	    commentList[cmailOldMove] != NULL &&
@@ -13958,7 +14421,7 @@ PositionToFEN(move, overrideCastling)
   }
 
   if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
-     gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) { 
+     gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier && gameInfo.variant != VariantMakruk ) { 
     /* En passant target square */
     if (move > backwardMostMove) {
         fromX = moveList[move - 1][0] - AAA;
@@ -14133,10 +14596,12 @@ ParseFEN(board, blackPlaysFirst, fen)
     }   /* assume possible unless obviously impossible */
     if(initialRights[0]!=NoRights && board[castlingRank[0]][initialRights[0]] != WhiteRook) board[CASTLING][0] = NoRights;
     if(initialRights[1]!=NoRights && board[castlingRank[1]][initialRights[1]] != WhiteRook) board[CASTLING][1] = NoRights;
-    if(initialRights[2]!=NoRights && board[castlingRank[2]][initialRights[2]] != WhiteKing) board[CASTLING][2] = NoRights;
+    if(initialRights[2]!=NoRights && board[castlingRank[2]][initialRights[2]] != WhiteUnicorn
+				  && board[castlingRank[2]][initialRights[2]] != WhiteKing) board[CASTLING][2] = NoRights;
     if(initialRights[3]!=NoRights && board[castlingRank[3]][initialRights[3]] != BlackRook) board[CASTLING][3] = NoRights;
     if(initialRights[4]!=NoRights && board[castlingRank[4]][initialRights[4]] != BlackRook) board[CASTLING][4] = NoRights;
-    if(initialRights[5]!=NoRights && board[castlingRank[5]][initialRights[5]] != BlackKing) board[CASTLING][5] = NoRights;
+    if(initialRights[5]!=NoRights && board[castlingRank[5]][initialRights[5]] != BlackUnicorn
+				  && board[castlingRank[5]][initialRights[5]] != BlackKing) board[CASTLING][5] = NoRights;
     FENrulePlies = 0;
 
     while(*p==' ') p++;
@@ -14151,12 +14616,18 @@ ParseFEN(board, blackPlaysFirst, fen)
              (gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) &&
              ( *p >= 'a' && *p < 'a' + gameInfo.boardWidth) ||
              ( *p >= 'A' && *p < 'A' + gameInfo.boardWidth)   ) {
-        char c = *p++; int whiteKingFile=-1, blackKingFile=-1;
+        char c = *p++; int whiteKingFile=NoRights, blackKingFile=NoRights;
 
         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
             if(board[BOARD_HEIGHT-1][i] == BlackKing) blackKingFile = i;
             if(board[0             ][i] == WhiteKing) whiteKingFile = i;
         }
+        if(gameInfo.variant == VariantTwoKings || gameInfo.variant == VariantKnightmate)
+            whiteKingFile = blackKingFile = BOARD_WIDTH >> 1; // for these variant scanning fails
+        if(whiteKingFile == NoRights || board[0][whiteKingFile] != WhiteUnicorn
+                                     && board[0][whiteKingFile] != WhiteKing) whiteKingFile = NoRights;
+        if(blackKingFile == NoRights || board[BOARD_HEIGHT-1][blackKingFile] != BlackUnicorn
+                                     && board[BOARD_HEIGHT-1][blackKingFile] != BlackKing) blackKingFile = NoRights;
         switch(c) {
           case'K':
               for(i=BOARD_RGHT-1; board[0][i]!=WhiteRook && i>whiteKingFile; i--);
@@ -14164,7 +14635,7 @@ ParseFEN(board, blackPlaysFirst, fen)
               board[CASTLING][2] = whiteKingFile;
               break;
           case'Q':
-              for(i=BOARD_LEFT; board[0][i]!=WhiteRook && i<whiteKingFile; i++);
+              for(i=BOARD_LEFT;  i<BOARD_RGHT && board[0][i]!=WhiteRook && i<whiteKingFile; i++);
               board[CASTLING][1] = i != whiteKingFile ? i : NoRights;
               board[CASTLING][2] = whiteKingFile;
               break;
@@ -14174,7 +14645,7 @@ ParseFEN(board, blackPlaysFirst, fen)
               board[CASTLING][5] = blackKingFile;
               break;
           case'q':
-              for(i=BOARD_LEFT; board[BOARD_HEIGHT-1][i]!=BlackRook && i<blackKingFile; i++);
+              for(i=BOARD_LEFT; i<BOARD_RGHT && board[BOARD_HEIGHT-1][i]!=BlackRook && i<blackKingFile; i++);
               board[CASTLING][4] = i != blackKingFile ? i : NoRights;
               board[CASTLING][5] = blackKingFile;
           case '-':
@@ -14206,6 +14677,8 @@ ParseFEN(board, blackPlaysFirst, fen)
               }
         }
       }
+      for(i=0; i<nrCastlingRights; i++)
+        if(board[CASTLING][i] != NoRights) initialRights[i] = board[CASTLING][i];
     if (appData.debugMode) {
         fprintf(debugFP, "FEN castling rights:");
         for(i=0; i<nrCastlingRights; i++)
@@ -14218,7 +14691,7 @@ ParseFEN(board, blackPlaysFirst, fen)
 
     /* read e.p. field in games that know e.p. capture */
     if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
-       gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) { 
+       gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier && gameInfo.variant != VariantMakruk ) { 
       if(*p=='-') {
         p++; board[EP_STATUS] = EP_NONE;
       } else {