2 * backend.c -- Common back end for X and Windows NT versions of
4 * Copyright 1991 by Digital Equipment Corporation, Maynard,
7 * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
8 * 2007, 2008, 2009 Free Software Foundation, Inc.
10 * Enhancements Copyright 2005 Alessandro Scotti
12 * The following terms apply to Digital Equipment Corporation's copyright
14 * ------------------------------------------------------------------------
17 * Permission to use, copy, modify, and distribute this software and its
18 * documentation for any purpose and without fee is hereby granted,
19 * provided that the above copyright notice appear in all copies and that
20 * both that copyright notice and this permission notice appear in
21 * supporting documentation, and that the name of Digital not be
22 * used in advertising or publicity pertaining to distribution of the
23 * software without specific, written prior permission.
25 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
26 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
27 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
28 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
29 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
30 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
32 * ------------------------------------------------------------------------
34 * The following terms apply to the enhanced version of XBoard
35 * distributed by the Free Software Foundation:
36 * ------------------------------------------------------------------------
38 * GNU XBoard is free software: you can redistribute it and/or modify
39 * it under the terms of the GNU General Public License as published by
40 * the Free Software Foundation, either version 3 of the License, or (at
41 * your option) any later version.
43 * GNU XBoard is distributed in the hope that it will be useful, but
44 * WITHOUT ANY WARRANTY; without even the implied warranty of
45 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
46 * General Public License for more details.
48 * You should have received a copy of the GNU General Public License
49 * along with this program. If not, see http://www.gnu.org/licenses/. *
51 *------------------------------------------------------------------------
52 ** See the file ChangeLog for a revision history. */
54 /* [AS] Also useful here for debugging */
58 #define DoSleep( n ) if( (n) != 0 ) Sleep( (n) );
62 #define DoSleep( n ) if( (n) >= 0) sleep(n)
72 #include <sys/types.h>
80 #else /* not STDC_HEADERS */
83 # else /* not HAVE_STRING_H */
85 # endif /* not HAVE_STRING_H */
86 #endif /* not STDC_HEADERS */
89 # include <sys/fcntl.h>
90 #else /* not HAVE_SYS_FCNTL_H */
93 # endif /* HAVE_FCNTL_H */
94 #endif /* not HAVE_SYS_FCNTL_H */
96 #if TIME_WITH_SYS_TIME
97 # include <sys/time.h>
101 # include <sys/time.h>
107 #if defined(_amigados) && !defined(__GNUC__)
112 extern int gettimeofday(struct timeval *, struct timezone *);
120 #include "frontend.h"
127 #include "backendz.h"
131 # define _(s) gettext (s)
132 # define N_(s) gettext_noop (s)
139 /* A point in time */
141 long sec; /* Assuming this is >= 32 bits */
142 int ms; /* Assuming this is >= 16 bits */
145 int establish P((void));
146 void read_from_player P((InputSourceRef isr, VOIDSTAR closure,
147 char *buf, int count, int error));
148 void read_from_ics P((InputSourceRef isr, VOIDSTAR closure,
149 char *buf, int count, int error));
150 void ics_printf P((char *format, ...));
151 void SendToICS P((char *s));
152 void SendToICSDelayed P((char *s, long msdelay));
153 void SendMoveToICS P((ChessMove moveType, int fromX, int fromY,
155 void HandleMachineMove P((char *message, ChessProgramState *cps));
156 int AutoPlayOneMove P((void));
157 int LoadGameOneMove P((ChessMove readAhead));
158 int LoadGameFromFile P((char *filename, int n, char *title, int useList));
159 int LoadPositionFromFile P((char *filename, int n, char *title));
160 int SavePositionToFile P((char *filename));
161 void ApplyMove P((int fromX, int fromY, int toX, int toY, int promoChar,
162 Board board, char *castle, char *ep));
163 void MakeMove P((int fromX, int fromY, int toX, int toY, int promoChar));
164 void ShowMove P((int fromX, int fromY, int toX, int toY));
165 int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
166 /*char*/int promoChar));
167 void BackwardInner P((int target));
168 void ForwardInner P((int target));
169 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
170 void EditPositionDone P((void));
171 void PrintOpponents P((FILE *fp));
172 void PrintPosition P((FILE *fp, int move));
173 void StartChessProgram P((ChessProgramState *cps));
174 void SendToProgram P((char *message, ChessProgramState *cps));
175 void SendMoveToProgram P((int moveNum, ChessProgramState *cps));
176 void ReceiveFromProgram P((InputSourceRef isr, VOIDSTAR closure,
177 char *buf, int count, int error));
178 void SendTimeControl P((ChessProgramState *cps,
179 int mps, long tc, int inc, int sd, int st));
180 char *TimeControlTagValue P((void));
181 void Attention P((ChessProgramState *cps));
182 void FeedMovesToProgram P((ChessProgramState *cps, int upto));
183 void ResurrectChessProgram P((void));
184 void DisplayComment P((int moveNumber, char *text));
185 void DisplayMove P((int moveNumber));
186 void DisplayAnalysis P((void));
188 void ParseGameHistory P((char *game));
189 void ParseBoard12 P((char *string));
190 void StartClocks P((void));
191 void SwitchClocks P((void));
192 void StopClocks P((void));
193 void ResetClocks P((void));
194 char *PGNDate P((void));
195 void SetGameInfo P((void));
196 Boolean ParseFEN P((Board board, int *blackPlaysFirst, char *fen));
197 int RegisterMove P((void));
198 void MakeRegisteredMove P((void));
199 void TruncateGame P((void));
200 int looking_at P((char *, int *, char *));
201 void CopyPlayerNameIntoFileName P((char **, char *));
202 char *SavePart P((char *));
203 int SaveGameOldStyle P((FILE *));
204 int SaveGamePGN P((FILE *));
205 void GetTimeMark P((TimeMark *));
206 long SubtractTimeMarks P((TimeMark *, TimeMark *));
207 int CheckFlags P((void));
208 long NextTickLength P((long));
209 void CheckTimeControl P((void));
210 void show_bytes P((FILE *, char *, int));
211 int string_to_rating P((char *str));
212 void ParseFeatures P((char* args, ChessProgramState *cps));
213 void InitBackEnd3 P((void));
214 void FeatureDone P((ChessProgramState* cps, int val));
215 void InitChessProgram P((ChessProgramState *cps, int setup));
216 void OutputKibitz(int window, char *text);
217 int PerpetualChase(int first, int last);
218 int EngineOutputIsUp();
219 void InitDrawingSizes(int x, int y);
222 extern void ConsoleCreate();
225 ChessProgramState *WhitePlayer();
226 void InsertIntoMemo P((int which, char *text)); // [HGM] kibitz: in engineo.c
227 int VerifyDisplayMode P(());
229 char *GetInfoFromComment( int, char * ); // [HGM] PV time: returns stripped comment
230 void InitEngineUCI( const char * iniDir, ChessProgramState * cps ); // [HGM] moved here from winboard.c
231 char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
232 char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
233 void ics_update_width P((int new_width));
234 extern char installDir[MSG_SIZ];
236 extern int tinyLayout, smallLayout;
237 ChessProgramStats programStats;
238 static int exiting = 0; /* [HGM] moved to top */
239 static int setboardSpoiledMachineBlack = 0 /*, errorExitFlag = 0*/;
240 int startedFromPositionFile = FALSE; Board filePosition; /* [HGM] loadPos */
241 char endingGame = 0; /* [HGM] crash: flag to prevent recursion of GameEnds() */
242 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS */
243 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
244 int lastIndex = 0; /* [HGM] autoinc: last game/position used in match mode */
245 int opponentKibitzes;
246 int lastSavedGame; /* [HGM] save: ID of game */
247 char chatPartner[MAX_CHAT][MSG_SIZ]; /* [HGM] chat: list of chatting partners */
248 extern int chatCount;
251 /* States for ics_getting_history */
253 #define H_REQUESTED 1
254 #define H_GOT_REQ_HEADER 2
255 #define H_GOT_UNREQ_HEADER 3
256 #define H_GETTING_MOVES 4
257 #define H_GOT_UNWANTED_HEADER 5
259 /* whosays values for GameEnds */
268 /* Maximum number of games in a cmail message */
269 #define CMAIL_MAX_GAMES 20
271 /* Different types of move when calling RegisterMove */
273 #define CMAIL_RESIGN 1
275 #define CMAIL_ACCEPT 3
277 /* Different types of result to remember for each game */
278 #define CMAIL_NOT_RESULT 0
279 #define CMAIL_OLD_RESULT 1
280 #define CMAIL_NEW_RESULT 2
282 /* Telnet protocol constants */
293 static char * safeStrCpy( char * dst, const char * src, size_t count )
295 assert( dst != NULL );
296 assert( src != NULL );
299 strncpy( dst, src, count );
300 dst[ count-1 ] = '\0';
304 /* Some compiler can't cast u64 to double
305 * This function do the job for us:
307 * We use the highest bit for cast, this only
308 * works if the highest bit is not
309 * in use (This should not happen)
311 * We used this for all compiler
314 u64ToDouble(u64 value)
317 u64 tmp = value & u64Const(0x7fffffffffffffff);
318 r = (double)(s64)tmp;
319 if (value & u64Const(0x8000000000000000))
320 r += 9.2233720368547758080e18; /* 2^63 */
324 /* Fake up flags for now, as we aren't keeping track of castling
325 availability yet. [HGM] Change of logic: the flag now only
326 indicates the type of castlings allowed by the rule of the game.
327 The actual rights themselves are maintained in the array
328 castlingRights, as part of the game history, and are not probed
334 int flags = F_ALL_CASTLE_OK;
335 if ((index % 2) == 0) flags |= F_WHITE_ON_MOVE;
336 switch (gameInfo.variant) {
338 flags &= ~F_ALL_CASTLE_OK;
339 case VariantGiveaway: // [HGM] moved this case label one down: seems Giveaway does have castling on ICC!
340 flags |= F_IGNORE_CHECK;
342 flags |= F_MANDATORY_CAPTURE; //[HGM] losers: sets flag so TestLegality rejects non-capts if capts exist
345 flags |= F_IGNORE_CHECK | F_ATOMIC_CAPTURE;
347 case VariantKriegspiel:
348 flags |= F_KRIEGSPIEL_CAPTURE;
350 case VariantCapaRandom:
351 case VariantFischeRandom:
352 flags |= F_FRC_TYPE_CASTLING; /* [HGM] enable this through flag */
353 case VariantNoCastle:
354 case VariantShatranj:
356 flags &= ~F_ALL_CASTLE_OK;
364 FILE *gameFileFP, *debugFP;
367 [AS] Note: sometimes, the sscanf() function is used to parse the input
368 into a fixed-size buffer. Because of this, we must be prepared to
369 receive strings as long as the size of the input buffer, which is currently
370 set to 4K for Windows and 8K for the rest.
371 So, we must either allocate sufficiently large buffers here, or
372 reduce the size of the input buffer in the input reading part.
375 char cmailMove[CMAIL_MAX_GAMES][MOVE_LEN], cmailMsg[MSG_SIZ];
376 char bookOutput[MSG_SIZ*10], thinkOutput[MSG_SIZ*10], lastHint[MSG_SIZ];
377 char thinkOutput1[MSG_SIZ*10];
379 ChessProgramState first, second;
381 /* premove variables */
384 int premoveFromX = 0;
385 int premoveFromY = 0;
386 int premovePromoChar = 0;
388 Boolean alarmSounded;
389 /* end premove variables */
391 char *ics_prefix = "$";
392 int ics_type = ICS_GENERIC;
394 int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0;
395 int pauseExamForwardMostMove = 0;
396 int nCmailGames = 0, nCmailResults = 0, nCmailMovesRegistered = 0;
397 int cmailMoveRegistered[CMAIL_MAX_GAMES], cmailResult[CMAIL_MAX_GAMES];
398 int cmailMsgLoaded = FALSE, cmailMailedMove = FALSE;
399 int cmailOldMove = -1, firstMove = TRUE, flipView = FALSE;
400 int blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE;
401 int searchTime = 0, pausing = FALSE, pauseExamInvalid = FALSE;
402 int whiteFlag = FALSE, blackFlag = FALSE;
403 int userOfferedDraw = FALSE;
404 int ics_user_moved = 0, ics_gamenum = -1, ics_getting_history = H_FALSE;
405 int matchMode = FALSE, hintRequested = FALSE, bookRequested = FALSE;
406 int cmailMoveType[CMAIL_MAX_GAMES];
407 long ics_clock_paused = 0;
408 ProcRef icsPR = NoProc, cmailPR = NoProc;
409 InputSourceRef telnetISR = NULL, fromUserISR = NULL, cmailISR = NULL;
410 GameMode gameMode = BeginningOfGame;
411 char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2];
412 char *commentList[MAX_MOVES], *cmailCommentList[CMAIL_MAX_GAMES];
413 ChessProgramStats_Move pvInfoList[MAX_MOVES]; /* [AS] Info about engine thinking */
414 int hiddenThinkOutputState = 0; /* [AS] */
415 int adjudicateLossThreshold = 0; /* [AS] Automatic adjudication */
416 int adjudicateLossPlies = 6;
417 char white_holding[64], black_holding[64];
418 TimeMark lastNodeCountTime;
419 long lastNodeCount=0;
420 int have_sent_ICS_logon = 0;
422 long whiteTimeRemaining, blackTimeRemaining, timeControl, timeIncrement;
423 long timeControl_2; /* [AS] Allow separate time controls */
424 char *fullTimeControlString = NULL; /* [HGM] secondary TC: merge of MPS, TC and inc */
425 long timeRemaining[2][MAX_MOVES];
427 TimeMark programStartTime;
428 char ics_handle[MSG_SIZ];
429 int have_set_title = 0;
431 /* animateTraining preserves the state of appData.animate
432 * when Training mode is activated. This allows the
433 * response to be animated when appData.animate == TRUE and
434 * appData.animateDragging == TRUE.
436 Boolean animateTraining;
442 Board boards[MAX_MOVES];
443 /* [HGM] Following 7 needed for accurate legality tests: */
444 signed char epStatus[MAX_MOVES];
445 signed char castlingRights[MAX_MOVES][BOARD_SIZE]; // stores files for pieces with castling rights or -1
446 signed char castlingRank[BOARD_SIZE]; // and corresponding ranks
447 signed char initialRights[BOARD_SIZE], FENcastlingRights[BOARD_SIZE], fileRights[BOARD_SIZE];
448 int nrCastlingRights; // For TwoKings, or to implement castling-unknown status
449 int initialRulePlies, FENrulePlies;
451 FILE *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
454 int mute; // mute all sounds
456 ChessSquare FIDEArray[2][BOARD_SIZE] = {
457 { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
458 WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
459 { BlackRook, BlackKnight, BlackBishop, BlackQueen,
460 BlackKing, BlackBishop, BlackKnight, BlackRook }
463 ChessSquare twoKingsArray[2][BOARD_SIZE] = {
464 { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
465 WhiteKing, WhiteKing, WhiteKnight, WhiteRook },
466 { BlackRook, BlackKnight, BlackBishop, BlackQueen,
467 BlackKing, BlackKing, BlackKnight, BlackRook }
470 ChessSquare KnightmateArray[2][BOARD_SIZE] = {
471 { WhiteRook, WhiteMan, WhiteBishop, WhiteQueen,
472 WhiteUnicorn, WhiteBishop, WhiteMan, WhiteRook },
473 { BlackRook, BlackMan, BlackBishop, BlackQueen,
474 BlackUnicorn, BlackBishop, BlackMan, BlackRook }
477 ChessSquare fairyArray[2][BOARD_SIZE] = { /* [HGM] Queen side differs from King side */
478 { WhiteCannon, WhiteNightrider, WhiteAlfil, WhiteQueen,
479 WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
480 { BlackCannon, BlackNightrider, BlackAlfil, BlackQueen,
481 BlackKing, BlackBishop, BlackKnight, BlackRook }
484 ChessSquare ShatranjArray[2][BOARD_SIZE] = { /* [HGM] (movGen knows about Shatranj Q and P) */
485 { WhiteRook, WhiteKnight, WhiteAlfil, WhiteKing,
486 WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
487 { BlackRook, BlackKnight, BlackAlfil, BlackKing,
488 BlackFerz, BlackAlfil, BlackKnight, BlackRook }
493 ChessSquare ShogiArray[2][BOARD_SIZE] = {
494 { WhiteQueen, WhiteKnight, WhiteFerz, WhiteWazir,
495 WhiteKing, WhiteWazir, WhiteFerz, WhiteKnight, WhiteQueen },
496 { BlackQueen, BlackKnight, BlackFerz, BlackWazir,
497 BlackKing, BlackWazir, BlackFerz, BlackKnight, BlackQueen }
500 ChessSquare XiangqiArray[2][BOARD_SIZE] = {
501 { WhiteRook, WhiteKnight, WhiteAlfil, WhiteFerz,
502 WhiteWazir, WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
503 { BlackRook, BlackKnight, BlackAlfil, BlackFerz,
504 BlackWazir, BlackFerz, BlackAlfil, BlackKnight, BlackRook }
507 ChessSquare CapablancaArray[2][BOARD_SIZE] = {
508 { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
509 WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
510 { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
511 BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
514 ChessSquare GreatArray[2][BOARD_SIZE] = {
515 { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
516 WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
517 { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
518 BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
521 ChessSquare JanusArray[2][BOARD_SIZE] = {
522 { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
523 WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
524 { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
525 BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
529 ChessSquare GothicArray[2][BOARD_SIZE] = {
530 { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
531 WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
532 { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
533 BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
536 #define GothicArray CapablancaArray
540 ChessSquare FalconArray[2][BOARD_SIZE] = {
541 { WhiteRook, WhiteKnight, WhiteBishop, WhiteLance, WhiteQueen,
542 WhiteKing, WhiteLance, WhiteBishop, WhiteKnight, WhiteRook },
543 { BlackRook, BlackKnight, BlackBishop, BlackLance, BlackQueen,
544 BlackKing, BlackLance, BlackBishop, BlackKnight, BlackRook }
547 #define FalconArray CapablancaArray
550 #else // !(BOARD_SIZE>=10)
551 #define XiangqiPosition FIDEArray
552 #define CapablancaArray FIDEArray
553 #define GothicArray FIDEArray
554 #define GreatArray FIDEArray
555 #endif // !(BOARD_SIZE>=10)
558 ChessSquare CourierArray[2][BOARD_SIZE] = {
559 { WhiteRook, WhiteKnight, WhiteAlfil, WhiteBishop, WhiteMan, WhiteKing,
560 WhiteFerz, WhiteWazir, WhiteBishop, WhiteAlfil, WhiteKnight, WhiteRook },
561 { BlackRook, BlackKnight, BlackAlfil, BlackBishop, BlackMan, BlackKing,
562 BlackFerz, BlackWazir, BlackBishop, BlackAlfil, BlackKnight, BlackRook }
564 #else // !(BOARD_SIZE>=12)
565 #define CourierArray CapablancaArray
566 #endif // !(BOARD_SIZE>=12)
569 Board initialPosition;
572 /* Convert str to a rating. Checks for special cases of "----",
574 "++++", etc. Also strips ()'s */
576 string_to_rating(str)
579 while(*str && !isdigit(*str)) ++str;
581 return 0; /* One of the special "no rating" cases */
589 /* Init programStats */
590 programStats.movelist[0] = 0;
591 programStats.depth = 0;
592 programStats.nr_moves = 0;
593 programStats.moves_left = 0;
594 programStats.nodes = 0;
595 programStats.time = -1; // [HGM] PGNtime: make invalid to recognize engine output
596 programStats.score = 0;
597 programStats.got_only_move = 0;
598 programStats.got_fail = 0;
599 programStats.line_is_book = 0;
605 int matched, min, sec;
607 ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
609 GetTimeMark(&programStartTime);
610 srand(programStartTime.ms); // [HGM] book: makes sure random is unpredictabe to msec level
613 programStats.ok_to_send = 1;
614 programStats.seen_stat = 0;
617 * Initialize game list
623 * Internet chess server status
625 if (appData.icsActive) {
626 appData.matchMode = FALSE;
627 appData.matchGames = 0;
629 appData.noChessProgram = !appData.zippyPlay;
631 appData.zippyPlay = FALSE;
632 appData.zippyTalk = FALSE;
633 appData.noChessProgram = TRUE;
635 if (*appData.icsHelper != NULLCHAR) {
636 appData.useTelnet = TRUE;
637 appData.telnetProgram = appData.icsHelper;
640 appData.zippyTalk = appData.zippyPlay = FALSE;
643 /* [AS] Initialize pv info list [HGM] and game state */
647 for( i=0; i<MAX_MOVES; i++ ) {
648 pvInfoList[i].depth = -1;
650 for( j=0; j<BOARD_SIZE; j++ ) castlingRights[i][j] = -1;
655 * Parse timeControl resource
657 if (!ParseTimeControl(appData.timeControl, appData.timeIncrement,
658 appData.movesPerSession)) {
660 snprintf(buf, sizeof(buf), _("bad timeControl option %s"), appData.timeControl);
661 DisplayFatalError(buf, 0, 2);
665 * Parse searchTime resource
667 if (*appData.searchTime != NULLCHAR) {
668 matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
670 searchTime = min * 60;
671 } else if (matched == 2) {
672 searchTime = min * 60 + sec;
675 snprintf(buf, sizeof(buf), _("bad searchTime option %s"), appData.searchTime);
676 DisplayFatalError(buf, 0, 2);
680 /* [AS] Adjudication threshold */
681 adjudicateLossThreshold = appData.adjudicateLossThreshold;
683 first.which = "first";
684 second.which = "second";
685 first.maybeThinking = second.maybeThinking = FALSE;
686 first.pr = second.pr = NoProc;
687 first.isr = second.isr = NULL;
688 first.sendTime = second.sendTime = 2;
689 first.sendDrawOffers = 1;
690 if (appData.firstPlaysBlack) {
691 first.twoMachinesColor = "black\n";
692 second.twoMachinesColor = "white\n";
694 first.twoMachinesColor = "white\n";
695 second.twoMachinesColor = "black\n";
697 first.program = appData.firstChessProgram;
698 second.program = appData.secondChessProgram;
699 first.host = appData.firstHost;
700 second.host = appData.secondHost;
701 first.dir = appData.firstDirectory;
702 second.dir = appData.secondDirectory;
703 first.other = &second;
704 second.other = &first;
705 first.initString = appData.initString;
706 second.initString = appData.secondInitString;
707 first.computerString = appData.firstComputerString;
708 second.computerString = appData.secondComputerString;
709 first.useSigint = second.useSigint = TRUE;
710 first.useSigterm = second.useSigterm = TRUE;
711 first.reuse = appData.reuseFirst;
712 second.reuse = appData.reuseSecond;
713 first.nps = appData.firstNPS; // [HGM] nps: copy nodes per second
714 second.nps = appData.secondNPS;
715 first.useSetboard = second.useSetboard = FALSE;
716 first.useSAN = second.useSAN = FALSE;
717 first.usePing = second.usePing = FALSE;
718 first.lastPing = second.lastPing = 0;
719 first.lastPong = second.lastPong = 0;
720 first.usePlayother = second.usePlayother = FALSE;
721 first.useColors = second.useColors = TRUE;
722 first.useUsermove = second.useUsermove = FALSE;
723 first.sendICS = second.sendICS = FALSE;
724 first.sendName = second.sendName = appData.icsActive;
725 first.sdKludge = second.sdKludge = FALSE;
726 first.stKludge = second.stKludge = FALSE;
727 TidyProgramName(first.program, first.host, first.tidy);
728 TidyProgramName(second.program, second.host, second.tidy);
729 first.matchWins = second.matchWins = 0;
730 strcpy(first.variants, appData.variant);
731 strcpy(second.variants, appData.variant);
732 first.analysisSupport = second.analysisSupport = 2; /* detect */
733 first.analyzing = second.analyzing = FALSE;
734 first.initDone = second.initDone = FALSE;
736 /* New features added by Tord: */
737 first.useFEN960 = FALSE; second.useFEN960 = FALSE;
738 first.useOOCastle = TRUE; second.useOOCastle = TRUE;
739 /* End of new features added by Tord. */
740 first.fenOverride = appData.fenOverride1;
741 second.fenOverride = appData.fenOverride2;
743 /* [HGM] time odds: set factor for each machine */
744 first.timeOdds = appData.firstTimeOdds;
745 second.timeOdds = appData.secondTimeOdds;
747 if(appData.timeOddsMode) {
748 norm = first.timeOdds;
749 if(norm > second.timeOdds) norm = second.timeOdds;
751 first.timeOdds /= norm;
752 second.timeOdds /= norm;
755 /* [HGM] secondary TC: how to handle sessions that do not fit in 'level'*/
756 first.accumulateTC = appData.firstAccumulateTC;
757 second.accumulateTC = appData.secondAccumulateTC;
758 first.maxNrOfSessions = second.maxNrOfSessions = 1;
761 first.debug = second.debug = FALSE;
762 first.supportsNPS = second.supportsNPS = UNKNOWN;
765 first.optionSettings = appData.firstOptions;
766 second.optionSettings = appData.secondOptions;
768 first.scoreIsAbsolute = appData.firstScoreIsAbsolute; /* [AS] */
769 second.scoreIsAbsolute = appData.secondScoreIsAbsolute; /* [AS] */
770 first.isUCI = appData.firstIsUCI; /* [AS] */
771 second.isUCI = appData.secondIsUCI; /* [AS] */
772 first.hasOwnBookUCI = appData.firstHasOwnBookUCI; /* [AS] */
773 second.hasOwnBookUCI = appData.secondHasOwnBookUCI; /* [AS] */
775 if (appData.firstProtocolVersion > PROTOVER ||
776 appData.firstProtocolVersion < 1) {
778 sprintf(buf, _("protocol version %d not supported"),
779 appData.firstProtocolVersion);
780 DisplayFatalError(buf, 0, 2);
782 first.protocolVersion = appData.firstProtocolVersion;
785 if (appData.secondProtocolVersion > PROTOVER ||
786 appData.secondProtocolVersion < 1) {
788 sprintf(buf, _("protocol version %d not supported"),
789 appData.secondProtocolVersion);
790 DisplayFatalError(buf, 0, 2);
792 second.protocolVersion = appData.secondProtocolVersion;
795 if (appData.icsActive) {
796 appData.clockMode = TRUE; /* changes dynamically in ICS mode */
797 } else if (*appData.searchTime != NULLCHAR || appData.noChessProgram) {
798 appData.clockMode = FALSE;
799 first.sendTime = second.sendTime = 0;
803 /* Override some settings from environment variables, for backward
804 compatibility. Unfortunately it's not feasible to have the env
805 vars just set defaults, at least in xboard. Ugh.
807 if (appData.icsActive && (appData.zippyPlay || appData.zippyTalk)) {
812 if (appData.noChessProgram) {
813 programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
814 sprintf(programVersion, "%s", PACKAGE_STRING);
816 /* [HGM] tidy: use tidy name, in stead of full pathname (which was probably a bug due to / vs \ ) */
817 programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
818 sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
821 if (!appData.icsActive) {
823 /* Check for variants that are supported only in ICS mode,
824 or not at all. Some that are accepted here nevertheless
825 have bugs; see comments below.
827 VariantClass variant = StringToVariant(appData.variant);
829 case VariantBughouse: /* need four players and two boards */
830 case VariantKriegspiel: /* need to hide pieces and move details */
831 /* case VariantFischeRandom: (Fabien: moved below) */
832 sprintf(buf, _("Variant %s supported only in ICS mode"), appData.variant);
833 DisplayFatalError(buf, 0, 2);
837 case VariantLoadable:
847 sprintf(buf, _("Unknown variant name %s"), appData.variant);
848 DisplayFatalError(buf, 0, 2);
851 case VariantXiangqi: /* [HGM] repetition rules not implemented */
852 case VariantFairy: /* [HGM] TestLegality definitely off! */
853 case VariantGothic: /* [HGM] should work */
854 case VariantCapablanca: /* [HGM] should work */
855 case VariantCourier: /* [HGM] initial forced moves not implemented */
856 case VariantShogi: /* [HGM] drops not tested for legality */
857 case VariantKnightmate: /* [HGM] should work */
858 case VariantCylinder: /* [HGM] untested */
859 case VariantFalcon: /* [HGM] untested */
860 case VariantCrazyhouse: /* holdings not shown, ([HGM] fixed that!)
861 offboard interposition not understood */
862 case VariantNormal: /* definitely works! */
863 case VariantWildCastle: /* pieces not automatically shuffled */
864 case VariantNoCastle: /* pieces not automatically shuffled */
865 case VariantFischeRandom: /* [HGM] works and shuffles pieces */
866 case VariantLosers: /* should work except for win condition,
867 and doesn't know captures are mandatory */
868 case VariantSuicide: /* should work except for win condition,
869 and doesn't know captures are mandatory */
870 case VariantGiveaway: /* should work except for win condition,
871 and doesn't know captures are mandatory */
872 case VariantTwoKings: /* should work */
873 case VariantAtomic: /* should work except for win condition */
874 case Variant3Check: /* should work except for win condition */
875 case VariantShatranj: /* should work except for all win conditions */
876 case VariantBerolina: /* might work if TestLegality is off */
877 case VariantCapaRandom: /* should work */
878 case VariantJanus: /* should work */
879 case VariantSuper: /* experimental */
880 case VariantGreat: /* experimental, requires legality testing to be off */
885 InitEngineUCI( installDir, &first ); // [HGM] moved here from winboard.c, to make available in xboard
886 InitEngineUCI( installDir, &second );
889 int NextIntegerFromString( char ** str, long * value )
894 while( *s == ' ' || *s == '\t' ) {
900 if( *s >= '0' && *s <= '9' ) {
901 while( *s >= '0' && *s <= '9' ) {
902 *value = *value * 10 + (*s - '0');
914 int NextTimeControlFromString( char ** str, long * value )
917 int result = NextIntegerFromString( str, &temp );
920 *value = temp * 60; /* Minutes */
923 result = NextIntegerFromString( str, &temp );
924 *value += temp; /* Seconds */
931 int NextSessionFromString( char ** str, int *moves, long * tc, long *inc)
932 { /* [HGM] routine added to read '+moves/time' for secondary time control */
933 int result = -1; long temp, temp2;
935 if(**str != '+') return -1; // old params remain in force!
937 if( NextTimeControlFromString( str, &temp ) ) return -1;
940 /* time only: incremental or sudden-death time control */
941 if(**str == '+') { /* increment follows; read it */
943 if(result = NextIntegerFromString( str, &temp2)) return -1;
946 *moves = 0; *tc = temp * 1000;
948 } else if(temp % 60 != 0) return -1; /* moves was given as min:sec */
950 (*str)++; /* classical time control */
951 result = NextTimeControlFromString( str, &temp2);
960 int GetTimeQuota(int movenr)
961 { /* [HGM] get time to add from the multi-session time-control string */
962 int moves=1; /* kludge to force reading of first session */
963 long time, increment;
964 char *s = fullTimeControlString;
966 if(appData.debugMode) fprintf(debugFP, "TC string = '%s'\n", fullTimeControlString);
968 if(moves) NextSessionFromString(&s, &moves, &time, &increment);
969 if(appData.debugMode) fprintf(debugFP, "mps=%d tc=%d inc=%d\n", moves, (int) time, (int) increment);
970 if(movenr == -1) return time; /* last move before new session */
971 if(!moves) return increment; /* current session is incremental */
972 if(movenr >= 0) movenr -= moves; /* we already finished this session */
973 } while(movenr >= -1); /* try again for next session */
975 return 0; // no new time quota on this move
979 ParseTimeControl(tc, ti, mps)
988 if(ti >= 0 && !strchr(tc, '+') && !strchr(tc, '/') ) mps = 0;
991 sprintf(buf, "+%d/%s+%d", mps, tc, ti);
992 else sprintf(buf, "+%s+%d", tc, ti);
995 sprintf(buf, "+%d/%s", mps, tc);
996 else sprintf(buf, "+%s", tc);
998 fullTimeControlString = StrSave(buf);
1000 if( NextTimeControlFromString( &tc, &tc1 ) != 0 ) {
1005 /* Parse second time control */
1008 if( NextTimeControlFromString( &tc, &tc2 ) != 0 ) {
1016 timeControl_2 = tc2 * 1000;
1026 timeControl = tc1 * 1000;
1029 timeIncrement = ti * 1000; /* convert to ms */
1030 movesPerSession = 0;
1033 movesPerSession = mps;
1041 if (appData.debugMode) {
1042 fprintf(debugFP, "%s\n", programVersion);
1045 if (appData.matchGames > 0) {
1046 appData.matchMode = TRUE;
1047 } else if (appData.matchMode) {
1048 appData.matchGames = 1;
1050 if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1051 appData.matchGames = appData.sameColorGames;
1052 if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1053 if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1054 if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1057 if (appData.noChessProgram || first.protocolVersion == 1) {
1060 /* kludge: allow timeout for initial "feature" commands */
1062 DisplayMessage("", _("Starting chess program"));
1063 ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1068 InitBackEnd3 P((void))
1070 GameMode initialMode;
1074 InitChessProgram(&first, startedFromSetupPosition);
1077 if (appData.icsActive) {
1079 /* [DM] Make a console window if needed [HGM] merged ifs */
1084 if (*appData.icsCommPort != NULLCHAR) {
1085 sprintf(buf, _("Could not open comm port %s"),
1086 appData.icsCommPort);
1088 snprintf(buf, sizeof(buf), _("Could not connect to host %s, port %s"),
1089 appData.icsHost, appData.icsPort);
1091 DisplayFatalError(buf, err, 1);
1096 AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1098 AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1099 } else if (appData.noChessProgram) {
1105 if (*appData.cmailGameName != NULLCHAR) {
1107 OpenLoopback(&cmailPR);
1109 AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1113 DisplayMessage("", "");
1114 if (StrCaseCmp(appData.initialMode, "") == 0) {
1115 initialMode = BeginningOfGame;
1116 } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1117 initialMode = TwoMachinesPlay;
1118 } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1119 initialMode = AnalyzeFile;
1120 } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1121 initialMode = AnalyzeMode;
1122 } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1123 initialMode = MachinePlaysWhite;
1124 } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1125 initialMode = MachinePlaysBlack;
1126 } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1127 initialMode = EditGame;
1128 } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1129 initialMode = EditPosition;
1130 } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1131 initialMode = Training;
1133 sprintf(buf, _("Unknown initialMode %s"), appData.initialMode);
1134 DisplayFatalError(buf, 0, 2);
1138 if (appData.matchMode) {
1139 /* Set up machine vs. machine match */
1140 if (appData.noChessProgram) {
1141 DisplayFatalError(_("Can't have a match with no chess programs"),
1147 if (*appData.loadGameFile != NULLCHAR) {
1148 int index = appData.loadGameIndex; // [HGM] autoinc
1149 if(index<0) lastIndex = index = 1;
1150 if (!LoadGameFromFile(appData.loadGameFile,
1152 appData.loadGameFile, FALSE)) {
1153 DisplayFatalError(_("Bad game file"), 0, 1);
1156 } else if (*appData.loadPositionFile != NULLCHAR) {
1157 int index = appData.loadPositionIndex; // [HGM] autoinc
1158 if(index<0) lastIndex = index = 1;
1159 if (!LoadPositionFromFile(appData.loadPositionFile,
1161 appData.loadPositionFile)) {
1162 DisplayFatalError(_("Bad position file"), 0, 1);
1167 } else if (*appData.cmailGameName != NULLCHAR) {
1168 /* Set up cmail mode */
1169 ReloadCmailMsgEvent(TRUE);
1171 /* Set up other modes */
1172 if (initialMode == AnalyzeFile) {
1173 if (*appData.loadGameFile == NULLCHAR) {
1174 DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1178 if (*appData.loadGameFile != NULLCHAR) {
1179 (void) LoadGameFromFile(appData.loadGameFile,
1180 appData.loadGameIndex,
1181 appData.loadGameFile, TRUE);
1182 } else if (*appData.loadPositionFile != NULLCHAR) {
1183 (void) LoadPositionFromFile(appData.loadPositionFile,
1184 appData.loadPositionIndex,
1185 appData.loadPositionFile);
1186 /* [HGM] try to make self-starting even after FEN load */
1187 /* to allow automatic setup of fairy variants with wtm */
1188 if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1189 gameMode = BeginningOfGame;
1190 setboardSpoiledMachineBlack = 1;
1192 /* [HGM] loadPos: make that every new game uses the setup */
1193 /* from file as long as we do not switch variant */
1194 if(!blackPlaysFirst) { int i;
1195 startedFromPositionFile = TRUE;
1196 CopyBoard(filePosition, boards[0]);
1197 for(i=0; i<BOARD_SIZE; i++) fileRights[i] = castlingRights[0][i];
1200 if (initialMode == AnalyzeMode) {
1201 if (appData.noChessProgram) {
1202 DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1205 if (appData.icsActive) {
1206 DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1210 } else if (initialMode == AnalyzeFile) {
1211 appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1212 ShowThinkingEvent();
1214 AnalysisPeriodicEvent(1);
1215 } else if (initialMode == MachinePlaysWhite) {
1216 if (appData.noChessProgram) {
1217 DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1221 if (appData.icsActive) {
1222 DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1226 MachineWhiteEvent();
1227 } else if (initialMode == MachinePlaysBlack) {
1228 if (appData.noChessProgram) {
1229 DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1233 if (appData.icsActive) {
1234 DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1238 MachineBlackEvent();
1239 } else if (initialMode == TwoMachinesPlay) {
1240 if (appData.noChessProgram) {
1241 DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1245 if (appData.icsActive) {
1246 DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1251 } else if (initialMode == EditGame) {
1253 } else if (initialMode == EditPosition) {
1254 EditPositionEvent();
1255 } else if (initialMode == Training) {
1256 if (*appData.loadGameFile == NULLCHAR) {
1257 DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1266 * Establish will establish a contact to a remote host.port.
1267 * Sets icsPR to a ProcRef for a process (or pseudo-process)
1268 * used to talk to the host.
1269 * Returns 0 if okay, error code if not.
1276 if (*appData.icsCommPort != NULLCHAR) {
1277 /* Talk to the host through a serial comm port */
1278 return OpenCommPort(appData.icsCommPort, &icsPR);
1280 } else if (*appData.gateway != NULLCHAR) {
1281 if (*appData.remoteShell == NULLCHAR) {
1282 /* Use the rcmd protocol to run telnet program on a gateway host */
1283 snprintf(buf, sizeof(buf), "%s %s %s",
1284 appData.telnetProgram, appData.icsHost, appData.icsPort);
1285 return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1288 /* Use the rsh program to run telnet program on a gateway host */
1289 if (*appData.remoteUser == NULLCHAR) {
1290 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1291 appData.gateway, appData.telnetProgram,
1292 appData.icsHost, appData.icsPort);
1294 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1295 appData.remoteShell, appData.gateway,
1296 appData.remoteUser, appData.telnetProgram,
1297 appData.icsHost, appData.icsPort);
1299 return StartChildProcess(buf, "", &icsPR);
1302 } else if (appData.useTelnet) {
1303 return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1306 /* TCP socket interface differs somewhat between
1307 Unix and NT; handle details in the front end.
1309 return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1314 show_bytes(fp, buf, count)
1320 if (*buf < 040 || *(unsigned char *) buf > 0177) {
1321 fprintf(fp, "\\%03o", *buf & 0xff);
1330 /* Returns an errno value */
1332 OutputMaybeTelnet(pr, message, count, outError)
1338 char buf[8192], *p, *q, *buflim;
1339 int left, newcount, outcount;
1341 if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1342 *appData.gateway != NULLCHAR) {
1343 if (appData.debugMode) {
1344 fprintf(debugFP, ">ICS: ");
1345 show_bytes(debugFP, message, count);
1346 fprintf(debugFP, "\n");
1348 return OutputToProcess(pr, message, count, outError);
1351 buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1358 if (appData.debugMode) {
1359 fprintf(debugFP, ">ICS: ");
1360 show_bytes(debugFP, buf, newcount);
1361 fprintf(debugFP, "\n");
1363 outcount = OutputToProcess(pr, buf, newcount, outError);
1364 if (outcount < newcount) return -1; /* to be sure */
1371 } else if (((unsigned char) *p) == TN_IAC) {
1372 *q++ = (char) TN_IAC;
1379 if (appData.debugMode) {
1380 fprintf(debugFP, ">ICS: ");
1381 show_bytes(debugFP, buf, newcount);
1382 fprintf(debugFP, "\n");
1384 outcount = OutputToProcess(pr, buf, newcount, outError);
1385 if (outcount < newcount) return -1; /* to be sure */
1390 read_from_player(isr, closure, message, count, error)
1397 int outError, outCount;
1398 static int gotEof = 0;
1400 /* Pass data read from player on to ICS */
1403 outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1404 if (outCount < count) {
1405 DisplayFatalError(_("Error writing to ICS"), outError, 1);
1407 } else if (count < 0) {
1408 RemoveInputSource(isr);
1409 DisplayFatalError(_("Error reading from keyboard"), error, 1);
1410 } else if (gotEof++ > 0) {
1411 RemoveInputSource(isr);
1412 DisplayFatalError(_("Got end of file from keyboard"), 0, 0);
1418 { // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1419 SendToICS("date\n");
1420 if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1423 /* added routine for printf style output to ics */
1424 void ics_printf(char *format, ...)
1426 char buffer[MSG_SIZ], *args;
1428 args = (char *)&format + sizeof(format);
1429 vsnprintf(buffer, sizeof(buffer), format, args);
1430 buffer[sizeof(buffer)-1] = '\0';
1438 int count, outCount, outError;
1440 if (icsPR == NULL) return;
1443 outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
1444 if (outCount < count) {
1445 DisplayFatalError(_("Error writing to ICS"), outError, 1);
1449 /* This is used for sending logon scripts to the ICS. Sending
1450 without a delay causes problems when using timestamp on ICC
1451 (at least on my machine). */
1453 SendToICSDelayed(s,msdelay)
1457 int count, outCount, outError;
1459 if (icsPR == NULL) return;
1462 if (appData.debugMode) {
1463 fprintf(debugFP, ">ICS: ");
1464 show_bytes(debugFP, s, count);
1465 fprintf(debugFP, "\n");
1467 outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
1469 if (outCount < count) {
1470 DisplayFatalError(_("Error writing to ICS"), outError, 1);
1475 /* Remove all highlighting escape sequences in s
1476 Also deletes any suffix starting with '('
1479 StripHighlightAndTitle(s)
1482 static char retbuf[MSG_SIZ];
1485 while (*s != NULLCHAR) {
1486 while (*s == '\033') {
1487 while (*s != NULLCHAR && !isalpha(*s)) s++;
1488 if (*s != NULLCHAR) s++;
1490 while (*s != NULLCHAR && *s != '\033') {
1491 if (*s == '(' || *s == '[') {
1502 /* Remove all highlighting escape sequences in s */
1507 static char retbuf[MSG_SIZ];
1510 while (*s != NULLCHAR) {
1511 while (*s == '\033') {
1512 while (*s != NULLCHAR && !isalpha(*s)) s++;
1513 if (*s != NULLCHAR) s++;
1515 while (*s != NULLCHAR && *s != '\033') {
1523 char *variantNames[] = VARIANT_NAMES;
1528 return variantNames[v];
1532 /* Identify a variant from the strings the chess servers use or the
1533 PGN Variant tag names we use. */
1540 VariantClass v = VariantNormal;
1541 int i, found = FALSE;
1546 /* [HGM] skip over optional board-size prefixes */
1547 if( sscanf(e, "%dx%d_", &i, &i) == 2 ||
1548 sscanf(e, "%dx%d+%d_", &i, &i, &i) == 3 ) {
1549 while( *e++ != '_');
1552 for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
1553 if (StrCaseStr(e, variantNames[i])) {
1554 v = (VariantClass) i;
1561 if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
1562 || StrCaseStr(e, "wild/fr")
1563 || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
1564 v = VariantFischeRandom;
1565 } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
1566 (i = 1, p = StrCaseStr(e, "w"))) {
1568 while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
1575 case 0: /* FICS only, actually */
1577 /* Castling legal even if K starts on d-file */
1578 v = VariantWildCastle;
1583 /* Castling illegal even if K & R happen to start in
1584 normal positions. */
1585 v = VariantNoCastle;
1598 /* Castling legal iff K & R start in normal positions */
1604 /* Special wilds for position setup; unclear what to do here */
1605 v = VariantLoadable;
1608 /* Bizarre ICC game */
1609 v = VariantTwoKings;
1612 v = VariantKriegspiel;
1618 v = VariantFischeRandom;
1621 v = VariantCrazyhouse;
1624 v = VariantBughouse;
1630 /* Not quite the same as FICS suicide! */
1631 v = VariantGiveaway;
1637 v = VariantShatranj;
1640 /* Temporary names for future ICC types. The name *will* change in
1641 the next xboard/WinBoard release after ICC defines it. */
1679 v = VariantCapablanca;
1682 v = VariantKnightmate;
1688 v = VariantCylinder;
1694 v = VariantCapaRandom;
1697 v = VariantBerolina;
1709 /* Found "wild" or "w" in the string but no number;
1710 must assume it's normal chess. */
1714 sprintf(buf, _("Unknown wild type %d"), wnum);
1715 DisplayError(buf, 0);
1721 if (appData.debugMode) {
1722 fprintf(debugFP, _("recognized '%s' (%d) as variant %s\n"),
1723 e, wnum, VariantName(v));
1728 static int leftover_start = 0, leftover_len = 0;
1729 char star_match[STAR_MATCH_N][MSG_SIZ];
1731 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
1732 advance *index beyond it, and set leftover_start to the new value of
1733 *index; else return FALSE. If pattern contains the character '*', it
1734 matches any sequence of characters not containing '\r', '\n', or the
1735 character following the '*' (if any), and the matched sequence(s) are
1736 copied into star_match.
1739 looking_at(buf, index, pattern)
1744 char *bufp = &buf[*index], *patternp = pattern;
1746 char *matchp = star_match[0];
1749 if (*patternp == NULLCHAR) {
1750 *index = leftover_start = bufp - buf;
1754 if (*bufp == NULLCHAR) return FALSE;
1755 if (*patternp == '*') {
1756 if (*bufp == *(patternp + 1)) {
1758 matchp = star_match[++star_count];
1762 } else if (*bufp == '\n' || *bufp == '\r') {
1764 if (*patternp == NULLCHAR)
1769 *matchp++ = *bufp++;
1773 if (*patternp != *bufp) return FALSE;
1780 SendToPlayer(data, length)
1784 int error, outCount;
1785 outCount = OutputToProcess(NoProc, data, length, &error);
1786 if (outCount < length) {
1787 DisplayFatalError(_("Error writing to display"), error, 1);
1792 PackHolding(packed, holding)
1804 switch (runlength) {
1815 sprintf(q, "%d", runlength);
1827 /* Telnet protocol requests from the front end */
1829 TelnetRequest(ddww, option)
1830 unsigned char ddww, option;
1832 unsigned char msg[3];
1833 int outCount, outError;
1835 if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
1837 if (appData.debugMode) {
1838 char buf1[8], buf2[8], *ddwwStr, *optionStr;
1854 sprintf(buf1, "%d", ddww);
1863 sprintf(buf2, "%d", option);
1866 fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
1871 outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
1873 DisplayFatalError(_("Error writing to ICS"), outError, 1);
1880 if (!appData.icsActive) return;
1881 TelnetRequest(TN_DO, TN_ECHO);
1887 if (!appData.icsActive) return;
1888 TelnetRequest(TN_DONT, TN_ECHO);
1892 CopyHoldings(Board board, char *holdings, ChessSquare lowestPiece)
1894 /* put the holdings sent to us by the server on the board holdings area */
1895 int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
1899 if(gameInfo.holdingsWidth < 2) return;
1901 if( (int)lowestPiece >= BlackPawn ) {
1904 holdingsStartRow = BOARD_HEIGHT-1;
1907 holdingsColumn = BOARD_WIDTH-1;
1908 countsColumn = BOARD_WIDTH-2;
1909 holdingsStartRow = 0;
1913 for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
1914 board[i][holdingsColumn] = EmptySquare;
1915 board[i][countsColumn] = (ChessSquare) 0;
1917 while( (p=*holdings++) != NULLCHAR ) {
1918 piece = CharToPiece( ToUpper(p) );
1919 if(piece == EmptySquare) continue;
1920 /*j = (int) piece - (int) WhitePawn;*/
1921 j = PieceToNumber(piece);
1922 if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
1923 if(j < 0) continue; /* should not happen */
1924 piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
1925 board[holdingsStartRow+j*direction][holdingsColumn] = piece;
1926 board[holdingsStartRow+j*direction][countsColumn]++;
1933 VariantSwitch(Board board, VariantClass newVariant)
1935 int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
1936 int oldCurrentMove = currentMove, oldForwardMostMove = forwardMostMove, oldBackwardMostMove = backwardMostMove;
1937 // Board tempBoard; int saveCastling[BOARD_SIZE], saveEP;
1939 startedFromPositionFile = FALSE;
1940 if(gameInfo.variant == newVariant) return;
1942 /* [HGM] This routine is called each time an assignment is made to
1943 * gameInfo.variant during a game, to make sure the board sizes
1944 * are set to match the new variant. If that means adding or deleting
1945 * holdings, we shift the playing board accordingly
1946 * This kludge is needed because in ICS observe mode, we get boards
1947 * of an ongoing game without knowing the variant, and learn about the
1948 * latter only later. This can be because of the move list we requested,
1949 * in which case the game history is refilled from the beginning anyway,
1950 * but also when receiving holdings of a crazyhouse game. In the latter
1951 * case we want to add those holdings to the already received position.
1955 if (appData.debugMode) {
1956 fprintf(debugFP, "Switch board from %s to %s\n",
1957 VariantName(gameInfo.variant), VariantName(newVariant));
1958 setbuf(debugFP, NULL);
1960 shuffleOpenings = 0; /* [HGM] shuffle */
1961 gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
1962 switch(newVariant) {
1964 newWidth = 9; newHeight = 9;
1965 gameInfo.holdingsSize = 7;
1966 case VariantBughouse:
1967 case VariantCrazyhouse:
1968 newHoldingsWidth = 2; break;
1970 newHoldingsWidth = gameInfo.holdingsSize = 0;
1973 if(newWidth != gameInfo.boardWidth ||
1974 newHeight != gameInfo.boardHeight ||
1975 newHoldingsWidth != gameInfo.holdingsWidth ) {
1977 /* shift position to new playing area, if needed */
1978 if(newHoldingsWidth > gameInfo.holdingsWidth) {
1979 for(i=0; i<BOARD_HEIGHT; i++)
1980 for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
1981 board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
1983 for(i=0; i<newHeight; i++) {
1984 board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
1985 board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
1987 } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
1988 for(i=0; i<BOARD_HEIGHT; i++)
1989 for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
1990 board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
1994 gameInfo.boardWidth = newWidth;
1995 gameInfo.boardHeight = newHeight;
1996 gameInfo.holdingsWidth = newHoldingsWidth;
1997 gameInfo.variant = newVariant;
1998 InitDrawingSizes(-2, 0);
2000 /* [HGM] The following should definitely be solved in a better way */
2001 InitPosition(FALSE); /* this sets up board[0], but also other stuff */
2002 } else { gameInfo.variant = newVariant; InitPosition(FALSE); }
2004 forwardMostMove = oldForwardMostMove;
2005 backwardMostMove = oldBackwardMostMove;
2006 currentMove = oldCurrentMove; /* InitPos reset these, but we need still to redraw the position */
2009 static int loggedOn = FALSE;
2011 /*-- Game start info cache: --*/
2013 char gs_kind[MSG_SIZ];
2014 static char player1Name[128] = "";
2015 static char player2Name[128] = "";
2016 static int player1Rating = -1;
2017 static int player2Rating = -1;
2018 /*----------------------------*/
2020 ColorClass curColor = ColorNormal;
2021 int suppressKibitz = 0;
2024 read_from_ics(isr, closure, data, count, error)
2031 #define BUF_SIZE 8192
2032 #define STARTED_NONE 0
2033 #define STARTED_MOVES 1
2034 #define STARTED_BOARD 2
2035 #define STARTED_OBSERVE 3
2036 #define STARTED_HOLDINGS 4
2037 #define STARTED_CHATTER 5
2038 #define STARTED_COMMENT 6
2039 #define STARTED_MOVES_NOHIDE 7
2041 static int started = STARTED_NONE;
2042 static char parse[20000];
2043 static int parse_pos = 0;
2044 static char buf[BUF_SIZE + 1];
2045 static int firstTime = TRUE, intfSet = FALSE;
2046 static ColorClass prevColor = ColorNormal;
2047 static int savingComment = FALSE;
2053 int backup; /* [DM] For zippy color lines */
2055 char talker[MSG_SIZ]; // [HGM] chat
2058 if (appData.debugMode) {
2060 fprintf(debugFP, "<ICS: ");
2061 show_bytes(debugFP, data, count);
2062 fprintf(debugFP, "\n");
2066 if (appData.debugMode) { int f = forwardMostMove;
2067 fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2068 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
2071 /* If last read ended with a partial line that we couldn't parse,
2072 prepend it to the new read and try again. */
2073 if (leftover_len > 0) {
2074 for (i=0; i<leftover_len; i++)
2075 buf[i] = buf[leftover_start + i];
2078 /* Copy in new characters, removing nulls and \r's */
2079 buf_len = leftover_len;
2080 for (i = 0; i < count; i++) {
2081 if (data[i] != NULLCHAR && data[i] != '\r')
2082 buf[buf_len++] = data[i];
2083 if(buf_len >= 5 && buf[buf_len-5]=='\n' && buf[buf_len-4]=='\\' &&
2084 buf[buf_len-3]==' ' && buf[buf_len-2]==' ' && buf[buf_len-1]==' ') {
2085 buf_len -= 5; // [HGM] ICS: join continuation line of Lasker 2.2.3 server with previous
2086 if(buf_len == 0 || buf[buf_len-1] != ' ')
2087 buf[buf_len++] = ' '; // add space (assumes ICS does not break lines within word)
2091 buf[buf_len] = NULLCHAR;
2092 next_out = leftover_len;
2096 while (i < buf_len) {
2097 /* Deal with part of the TELNET option negotiation
2098 protocol. We refuse to do anything beyond the
2099 defaults, except that we allow the WILL ECHO option,
2100 which ICS uses to turn off password echoing when we are
2101 directly connected to it. We reject this option
2102 if localLineEditing mode is on (always on in xboard)
2103 and we are talking to port 23, which might be a real
2104 telnet server that will try to keep WILL ECHO on permanently.
2106 if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2107 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2108 unsigned char option;
2110 switch ((unsigned char) buf[++i]) {
2112 if (appData.debugMode)
2113 fprintf(debugFP, "\n<WILL ");
2114 switch (option = (unsigned char) buf[++i]) {
2116 if (appData.debugMode)
2117 fprintf(debugFP, "ECHO ");
2118 /* Reply only if this is a change, according
2119 to the protocol rules. */
2120 if (remoteEchoOption) break;
2121 if (appData.localLineEditing &&
2122 atoi(appData.icsPort) == TN_PORT) {
2123 TelnetRequest(TN_DONT, TN_ECHO);
2126 TelnetRequest(TN_DO, TN_ECHO);
2127 remoteEchoOption = TRUE;
2131 if (appData.debugMode)
2132 fprintf(debugFP, "%d ", option);
2133 /* Whatever this is, we don't want it. */
2134 TelnetRequest(TN_DONT, option);
2139 if (appData.debugMode)
2140 fprintf(debugFP, "\n<WONT ");
2141 switch (option = (unsigned char) buf[++i]) {
2143 if (appData.debugMode)
2144 fprintf(debugFP, "ECHO ");
2145 /* Reply only if this is a change, according
2146 to the protocol rules. */
2147 if (!remoteEchoOption) break;
2149 TelnetRequest(TN_DONT, TN_ECHO);
2150 remoteEchoOption = FALSE;
2153 if (appData.debugMode)
2154 fprintf(debugFP, "%d ", (unsigned char) option);
2155 /* Whatever this is, it must already be turned
2156 off, because we never agree to turn on
2157 anything non-default, so according to the
2158 protocol rules, we don't reply. */
2163 if (appData.debugMode)
2164 fprintf(debugFP, "\n<DO ");
2165 switch (option = (unsigned char) buf[++i]) {
2167 /* Whatever this is, we refuse to do it. */
2168 if (appData.debugMode)
2169 fprintf(debugFP, "%d ", option);
2170 TelnetRequest(TN_WONT, option);
2175 if (appData.debugMode)
2176 fprintf(debugFP, "\n<DONT ");
2177 switch (option = (unsigned char) buf[++i]) {
2179 if (appData.debugMode)
2180 fprintf(debugFP, "%d ", option);
2181 /* Whatever this is, we are already not doing
2182 it, because we never agree to do anything
2183 non-default, so according to the protocol
2184 rules, we don't reply. */
2189 if (appData.debugMode)
2190 fprintf(debugFP, "\n<IAC ");
2191 /* Doubled IAC; pass it through */
2195 if (appData.debugMode)
2196 fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
2197 /* Drop all other telnet commands on the floor */
2200 if (oldi > next_out)
2201 SendToPlayer(&buf[next_out], oldi - next_out);
2207 /* OK, this at least will *usually* work */
2208 if (!loggedOn && looking_at(buf, &i, "ics%")) {
2212 if (loggedOn && !intfSet) {
2213 if (ics_type == ICS_ICC) {
2215 "/set-quietly interface %s\n/set-quietly style 12\n",
2218 } else if (ics_type == ICS_CHESSNET) {
2219 sprintf(str, "/style 12\n");
2221 strcpy(str, "alias $ @\n$set interface ");
2222 strcat(str, programVersion);
2223 strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
2225 strcat(str, "$iset nohighlight 1\n");
2227 strcat(str, "$iset lock 1\n$style 12\n");
2233 if (started == STARTED_COMMENT) {
2234 /* Accumulate characters in comment */
2235 parse[parse_pos++] = buf[i];
2236 if (buf[i] == '\n') {
2237 parse[parse_pos] = NULLCHAR;
2238 if(chattingPartner>=0) {
2240 sprintf(mess, "%s%s", talker, parse);
2241 OutputChatMessage(chattingPartner, mess);
2242 chattingPartner = -1;
2244 if(!suppressKibitz) // [HGM] kibitz
2245 AppendComment(forwardMostMove, StripHighlight(parse));
2246 else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
2247 int nrDigit = 0, nrAlph = 0, i;
2248 if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
2249 { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
2250 parse[parse_pos] = NULLCHAR;
2251 // try to be smart: if it does not look like search info, it should go to
2252 // ICS interaction window after all, not to engine-output window.
2253 for(i=0; i<parse_pos; i++) { // count letters and digits
2254 nrDigit += (parse[i] >= '0' && parse[i] <= '9');
2255 nrAlph += (parse[i] >= 'a' && parse[i] <= 'z');
2256 nrAlph += (parse[i] >= 'A' && parse[i] <= 'Z');
2258 if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
2259 int depth=0; float score;
2260 if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
2261 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
2262 pvInfoList[forwardMostMove-1].depth = depth;
2263 pvInfoList[forwardMostMove-1].score = 100*score;
2265 OutputKibitz(suppressKibitz, parse);
2268 sprintf(tmp, _("your opponent kibitzes: %s"), parse);
2269 SendToPlayer(tmp, strlen(tmp));
2272 started = STARTED_NONE;
2274 /* Don't match patterns against characters in chatter */
2279 if (started == STARTED_CHATTER) {
2280 if (buf[i] != '\n') {
2281 /* Don't match patterns against characters in chatter */
2285 started = STARTED_NONE;
2288 /* Kludge to deal with rcmd protocol */
2289 if (firstTime && looking_at(buf, &i, "\001*")) {
2290 DisplayFatalError(&buf[1], 0, 1);
2296 if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
2299 if (appData.debugMode)
2300 fprintf(debugFP, "ics_type %d\n", ics_type);
2303 if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
2304 ics_type = ICS_FICS;
2306 if (appData.debugMode)
2307 fprintf(debugFP, "ics_type %d\n", ics_type);
2310 if (!loggedOn && looking_at(buf, &i, "chess.net")) {
2311 ics_type = ICS_CHESSNET;
2313 if (appData.debugMode)
2314 fprintf(debugFP, "ics_type %d\n", ics_type);
2319 (looking_at(buf, &i, "\"*\" is *a registered name") ||
2320 looking_at(buf, &i, "Logging you in as \"*\"") ||
2321 looking_at(buf, &i, "will be \"*\""))) {
2322 strcpy(ics_handle, star_match[0]);
2326 if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
2328 snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
2329 DisplayIcsInteractionTitle(buf);
2330 have_set_title = TRUE;
2333 /* skip finger notes */
2334 if (started == STARTED_NONE &&
2335 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
2336 (buf[i] == '1' && buf[i+1] == '0')) &&
2337 buf[i+2] == ':' && buf[i+3] == ' ') {
2338 started = STARTED_CHATTER;
2343 /* skip formula vars */
2344 if (started == STARTED_NONE &&
2345 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
2346 started = STARTED_CHATTER;
2352 // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
2353 if (appData.autoKibitz && started == STARTED_NONE &&
2354 !appData.icsEngineAnalyze && // [HGM] [DM] ICS analyze
2355 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
2356 if(looking_at(buf, &i, "* kibitzes: ") &&
2357 (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
2358 StrStr(star_match[0], gameInfo.black) == star_match[0] )) { // kibitz of self or opponent
2359 suppressKibitz = TRUE;
2360 if((StrStr(star_match[0], gameInfo.white) == star_match[0]
2361 && (gameMode == IcsPlayingWhite)) ||
2362 (StrStr(star_match[0], gameInfo.black) == star_match[0]
2363 && (gameMode == IcsPlayingBlack)) ) // opponent kibitz
2364 started = STARTED_CHATTER; // own kibitz we simply discard
2366 started = STARTED_COMMENT; // make sure it will be collected in parse[]
2367 parse_pos = 0; parse[0] = NULLCHAR;
2368 savingComment = TRUE;
2369 suppressKibitz = gameMode != IcsObserving ? 2 :
2370 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
2374 if(looking_at(buf, &i, "kibitzed to")) { // suppress the acknowledgements of our own autoKibitz
2375 started = STARTED_CHATTER;
2376 suppressKibitz = TRUE;
2378 } // [HGM] kibitz: end of patch
2380 //if(appData.debugMode) fprintf(debugFP, "hunt for tell, buf = %s\n", buf+i);
2382 // [HGM] chat: intercept tells by users for which we have an open chat window
2384 if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
2385 looking_at(buf, &i, "* whispers:") ||
2386 looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
2387 looking_at(buf, &i, "*(*)(*):") && sscanf(star_match[2], "%d", &channel) == 1 )) {
2389 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
2390 chattingPartner = -1;
2392 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
2393 for(p=0; p<MAX_CHAT; p++) {
2394 if(channel == atoi(chatPartner[p])) {
2395 talker[0] = '['; strcat(talker, "]");
2396 chattingPartner = p; break;
2399 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
2400 for(p=0; p<MAX_CHAT; p++) {
2401 if(!strcmp("WHISPER", chatPartner[p])) {
2402 talker[0] = '['; strcat(talker, "]");
2403 chattingPartner = p; break;
2406 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
2407 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
2409 chattingPartner = p; break;
2411 if(chattingPartner<0) i = oldi; else {
2412 started = STARTED_COMMENT;
2413 parse_pos = 0; parse[0] = NULLCHAR;
2414 savingComment = TRUE;
2415 suppressKibitz = TRUE;
2417 } // [HGM] chat: end of patch
2419 if (appData.zippyTalk || appData.zippyPlay) {
2420 /* [DM] Backup address for color zippy lines */
2424 if (loggedOn == TRUE)
2425 if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
2426 (appData.zippyPlay && ZippyMatch(buf, &backup)));
2428 if (ZippyControl(buf, &i) ||
2429 ZippyConverse(buf, &i) ||
2430 (appData.zippyPlay && ZippyMatch(buf, &i))) {
2432 if (!appData.colorize) continue;
2436 } // [DM] 'else { ' deleted
2438 /* Regular tells and says */
2439 (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
2440 looking_at(buf, &i, "* (your partner) tells you: ") ||
2441 looking_at(buf, &i, "* says: ") ||
2442 /* Don't color "message" or "messages" output */
2443 (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
2444 looking_at(buf, &i, "*. * at *:*: ") ||
2445 looking_at(buf, &i, "--* (*:*): ") ||
2446 /* Message notifications (same color as tells) */
2447 looking_at(buf, &i, "* has left a message ") ||
2448 looking_at(buf, &i, "* just sent you a message:\n") ||
2449 /* Whispers and kibitzes */
2450 (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
2451 looking_at(buf, &i, "* kibitzes: ") ||
2453 (tkind = 3, looking_at(buf, &i, "*(*: "))) {
2455 if (tkind == 1 && strchr(star_match[0], ':')) {
2456 /* Avoid "tells you:" spoofs in channels */
2459 if (star_match[0][0] == NULLCHAR ||
2460 strchr(star_match[0], ' ') ||
2461 (tkind == 3 && strchr(star_match[1], ' '))) {
2462 /* Reject bogus matches */
2465 if (appData.colorize) {
2466 if (oldi > next_out) {
2467 SendToPlayer(&buf[next_out], oldi - next_out);
2472 Colorize(ColorTell, FALSE);
2473 curColor = ColorTell;
2476 Colorize(ColorKibitz, FALSE);
2477 curColor = ColorKibitz;
2480 p = strrchr(star_match[1], '(');
2487 Colorize(ColorChannel1, FALSE);
2488 curColor = ColorChannel1;
2490 Colorize(ColorChannel, FALSE);
2491 curColor = ColorChannel;
2495 curColor = ColorNormal;
2499 if (started == STARTED_NONE && appData.autoComment &&
2500 (gameMode == IcsObserving ||
2501 gameMode == IcsPlayingWhite ||
2502 gameMode == IcsPlayingBlack)) {
2503 parse_pos = i - oldi;
2504 memcpy(parse, &buf[oldi], parse_pos);
2505 parse[parse_pos] = NULLCHAR;
2506 started = STARTED_COMMENT;
2507 savingComment = TRUE;
2509 started = STARTED_CHATTER;
2510 savingComment = FALSE;
2517 if (looking_at(buf, &i, "* s-shouts: ") ||
2518 looking_at(buf, &i, "* c-shouts: ")) {
2519 if (appData.colorize) {
2520 if (oldi > next_out) {
2521 SendToPlayer(&buf[next_out], oldi - next_out);
2524 Colorize(ColorSShout, FALSE);
2525 curColor = ColorSShout;
2528 started = STARTED_CHATTER;
2532 if (looking_at(buf, &i, "--->")) {
2537 if (looking_at(buf, &i, "* shouts: ") ||
2538 looking_at(buf, &i, "--> ")) {
2539 if (appData.colorize) {
2540 if (oldi > next_out) {
2541 SendToPlayer(&buf[next_out], oldi - next_out);
2544 Colorize(ColorShout, FALSE);
2545 curColor = ColorShout;
2548 started = STARTED_CHATTER;
2552 if (looking_at( buf, &i, "Challenge:")) {
2553 if (appData.colorize) {
2554 if (oldi > next_out) {
2555 SendToPlayer(&buf[next_out], oldi - next_out);
2558 Colorize(ColorChallenge, FALSE);
2559 curColor = ColorChallenge;
2565 if (looking_at(buf, &i, "* offers you") ||
2566 looking_at(buf, &i, "* offers to be") ||
2567 looking_at(buf, &i, "* would like to") ||
2568 looking_at(buf, &i, "* requests to") ||
2569 looking_at(buf, &i, "Your opponent offers") ||
2570 looking_at(buf, &i, "Your opponent requests")) {
2572 if (appData.colorize) {
2573 if (oldi > next_out) {
2574 SendToPlayer(&buf[next_out], oldi - next_out);
2577 Colorize(ColorRequest, FALSE);
2578 curColor = ColorRequest;
2583 if (looking_at(buf, &i, "* (*) seeking")) {
2584 if (appData.colorize) {
2585 if (oldi > next_out) {
2586 SendToPlayer(&buf[next_out], oldi - next_out);
2589 Colorize(ColorSeek, FALSE);
2590 curColor = ColorSeek;
2595 if (looking_at(buf, &i, "\\ ")) {
2596 if (prevColor != ColorNormal) {
2597 if (oldi > next_out) {
2598 SendToPlayer(&buf[next_out], oldi - next_out);
2601 Colorize(prevColor, TRUE);
2602 curColor = prevColor;
2604 if (savingComment) {
2605 parse_pos = i - oldi;
2606 memcpy(parse, &buf[oldi], parse_pos);
2607 parse[parse_pos] = NULLCHAR;
2608 started = STARTED_COMMENT;
2610 started = STARTED_CHATTER;
2615 if (looking_at(buf, &i, "Black Strength :") ||
2616 looking_at(buf, &i, "<<< style 10 board >>>") ||
2617 looking_at(buf, &i, "<10>") ||
2618 looking_at(buf, &i, "#@#")) {
2619 /* Wrong board style */
2621 SendToICS(ics_prefix);
2622 SendToICS("set style 12\n");
2623 SendToICS(ics_prefix);
2624 SendToICS("refresh\n");
2628 if (!have_sent_ICS_logon && looking_at(buf, &i, "login:")) {
2630 have_sent_ICS_logon = 1;
2634 if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
2635 (looking_at(buf, &i, "\n<12> ") ||
2636 looking_at(buf, &i, "<12> "))) {
2638 if (oldi > next_out) {
2639 SendToPlayer(&buf[next_out], oldi - next_out);
2642 started = STARTED_BOARD;
2647 if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
2648 looking_at(buf, &i, "<b1> ")) {
2649 if (oldi > next_out) {
2650 SendToPlayer(&buf[next_out], oldi - next_out);
2653 started = STARTED_HOLDINGS;
2658 if (looking_at(buf, &i, "* *vs. * *--- *")) {
2660 /* Header for a move list -- first line */
2662 switch (ics_getting_history) {
2666 case BeginningOfGame:
2667 /* User typed "moves" or "oldmoves" while we
2668 were idle. Pretend we asked for these
2669 moves and soak them up so user can step
2670 through them and/or save them.
2673 gameMode = IcsObserving;
2676 ics_getting_history = H_GOT_UNREQ_HEADER;
2678 case EditGame: /*?*/
2679 case EditPosition: /*?*/
2680 /* Should above feature work in these modes too? */
2681 /* For now it doesn't */
2682 ics_getting_history = H_GOT_UNWANTED_HEADER;
2685 ics_getting_history = H_GOT_UNWANTED_HEADER;
2690 /* Is this the right one? */
2691 if (gameInfo.white && gameInfo.black &&
2692 strcmp(gameInfo.white, star_match[0]) == 0 &&
2693 strcmp(gameInfo.black, star_match[2]) == 0) {
2695 ics_getting_history = H_GOT_REQ_HEADER;
2698 case H_GOT_REQ_HEADER:
2699 case H_GOT_UNREQ_HEADER:
2700 case H_GOT_UNWANTED_HEADER:
2701 case H_GETTING_MOVES:
2702 /* Should not happen */
2703 DisplayError(_("Error gathering move list: two headers"), 0);
2704 ics_getting_history = H_FALSE;
2708 /* Save player ratings into gameInfo if needed */
2709 if ((ics_getting_history == H_GOT_REQ_HEADER ||
2710 ics_getting_history == H_GOT_UNREQ_HEADER) &&
2711 (gameInfo.whiteRating == -1 ||
2712 gameInfo.blackRating == -1)) {
2714 gameInfo.whiteRating = string_to_rating(star_match[1]);
2715 gameInfo.blackRating = string_to_rating(star_match[3]);
2716 if (appData.debugMode)
2717 fprintf(debugFP, _("Ratings from header: W %d, B %d\n"),
2718 gameInfo.whiteRating, gameInfo.blackRating);
2723 if (looking_at(buf, &i,
2724 "* * match, initial time: * minute*, increment: * second")) {
2725 /* Header for a move list -- second line */
2726 /* Initial board will follow if this is a wild game */
2727 if (gameInfo.event != NULL) free(gameInfo.event);
2728 sprintf(str, "ICS %s %s match", star_match[0], star_match[1]);
2729 gameInfo.event = StrSave(str);
2730 /* [HGM] we switched variant. Translate boards if needed. */
2731 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
2735 if (looking_at(buf, &i, "Move ")) {
2736 /* Beginning of a move list */
2737 switch (ics_getting_history) {
2739 /* Normally should not happen */
2740 /* Maybe user hit reset while we were parsing */
2743 /* Happens if we are ignoring a move list that is not
2744 * the one we just requested. Common if the user
2745 * tries to observe two games without turning off
2748 case H_GETTING_MOVES:
2749 /* Should not happen */
2750 DisplayError(_("Error gathering move list: nested"), 0);
2751 ics_getting_history = H_FALSE;
2753 case H_GOT_REQ_HEADER:
2754 ics_getting_history = H_GETTING_MOVES;
2755 started = STARTED_MOVES;
2757 if (oldi > next_out) {
2758 SendToPlayer(&buf[next_out], oldi - next_out);
2761 case H_GOT_UNREQ_HEADER:
2762 ics_getting_history = H_GETTING_MOVES;
2763 started = STARTED_MOVES_NOHIDE;
2766 case H_GOT_UNWANTED_HEADER:
2767 ics_getting_history = H_FALSE;
2773 if (looking_at(buf, &i, "% ") ||
2774 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
2775 && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
2776 savingComment = FALSE;
2779 case STARTED_MOVES_NOHIDE:
2780 memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
2781 parse[parse_pos + i - oldi] = NULLCHAR;
2782 ParseGameHistory(parse);
2784 if (appData.zippyPlay && first.initDone) {
2785 FeedMovesToProgram(&first, forwardMostMove);
2786 if (gameMode == IcsPlayingWhite) {
2787 if (WhiteOnMove(forwardMostMove)) {
2788 if (first.sendTime) {
2789 if (first.useColors) {
2790 SendToProgram("black\n", &first);
2792 SendTimeRemaining(&first, TRUE);
2794 if (first.useColors) {
2795 SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
2797 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
2798 first.maybeThinking = TRUE;
2800 if (first.usePlayother) {
2801 if (first.sendTime) {
2802 SendTimeRemaining(&first, TRUE);
2804 SendToProgram("playother\n", &first);
2810 } else if (gameMode == IcsPlayingBlack) {
2811 if (!WhiteOnMove(forwardMostMove)) {
2812 if (first.sendTime) {
2813 if (first.useColors) {
2814 SendToProgram("white\n", &first);
2816 SendTimeRemaining(&first, FALSE);
2818 if (first.useColors) {
2819 SendToProgram("black\n", &first);
2821 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
2822 first.maybeThinking = TRUE;
2824 if (first.usePlayother) {
2825 if (first.sendTime) {
2826 SendTimeRemaining(&first, FALSE);
2828 SendToProgram("playother\n", &first);
2837 if (gameMode == IcsObserving && ics_gamenum == -1) {
2838 /* Moves came from oldmoves or moves command
2839 while we weren't doing anything else.
2841 currentMove = forwardMostMove;
2842 ClearHighlights();/*!!could figure this out*/
2843 flipView = appData.flipView;
2844 DrawPosition(FALSE, boards[currentMove]);
2845 DisplayBothClocks();
2846 sprintf(str, "%s vs. %s",
2847 gameInfo.white, gameInfo.black);
2851 /* Moves were history of an active game */
2852 if (gameInfo.resultDetails != NULL) {
2853 free(gameInfo.resultDetails);
2854 gameInfo.resultDetails = NULL;
2857 HistorySet(parseList, backwardMostMove,
2858 forwardMostMove, currentMove-1);
2859 DisplayMove(currentMove - 1);
2860 if (started == STARTED_MOVES) next_out = i;
2861 started = STARTED_NONE;
2862 ics_getting_history = H_FALSE;
2865 case STARTED_OBSERVE:
2866 started = STARTED_NONE;
2867 SendToICS(ics_prefix);
2868 SendToICS("refresh\n");
2874 if(bookHit) { // [HGM] book: simulate book reply
2875 static char bookMove[MSG_SIZ]; // a bit generous?
2877 programStats.nodes = programStats.depth = programStats.time =
2878 programStats.score = programStats.got_only_move = 0;
2879 sprintf(programStats.movelist, "%s (xbook)", bookHit);
2881 strcpy(bookMove, "move ");
2882 strcat(bookMove, bookHit);
2883 HandleMachineMove(bookMove, &first);
2888 if ((started == STARTED_MOVES || started == STARTED_BOARD ||
2889 started == STARTED_HOLDINGS ||
2890 started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
2891 /* Accumulate characters in move list or board */
2892 parse[parse_pos++] = buf[i];
2895 /* Start of game messages. Mostly we detect start of game
2896 when the first board image arrives. On some versions
2897 of the ICS, though, we need to do a "refresh" after starting
2898 to observe in order to get the current board right away. */
2899 if (looking_at(buf, &i, "Adding game * to observation list")) {
2900 started = STARTED_OBSERVE;
2904 /* Handle auto-observe */
2905 if (appData.autoObserve &&
2906 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
2907 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
2909 /* Choose the player that was highlighted, if any. */
2910 if (star_match[0][0] == '\033' ||
2911 star_match[1][0] != '\033') {
2912 player = star_match[0];
2914 player = star_match[2];
2916 sprintf(str, "%sobserve %s\n",
2917 ics_prefix, StripHighlightAndTitle(player));
2920 /* Save ratings from notify string */
2921 strcpy(player1Name, star_match[0]);
2922 player1Rating = string_to_rating(star_match[1]);
2923 strcpy(player2Name, star_match[2]);
2924 player2Rating = string_to_rating(star_match[3]);
2926 if (appData.debugMode)
2928 "Ratings from 'Game notification:' %s %d, %s %d\n",
2929 player1Name, player1Rating,
2930 player2Name, player2Rating);
2935 /* Deal with automatic examine mode after a game,
2936 and with IcsObserving -> IcsExamining transition */
2937 if (looking_at(buf, &i, "Entering examine mode for game *") ||
2938 looking_at(buf, &i, "has made you an examiner of game *")) {
2940 int gamenum = atoi(star_match[0]);
2941 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
2942 gamenum == ics_gamenum) {
2943 /* We were already playing or observing this game;
2944 no need to refetch history */
2945 gameMode = IcsExamining;
2947 pauseExamForwardMostMove = forwardMostMove;
2948 } else if (currentMove < forwardMostMove) {
2949 ForwardInner(forwardMostMove);
2952 /* I don't think this case really can happen */
2953 SendToICS(ics_prefix);
2954 SendToICS("refresh\n");
2959 /* Error messages */
2960 // if (ics_user_moved) {
2961 if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
2962 if (looking_at(buf, &i, "Illegal move") ||
2963 looking_at(buf, &i, "Not a legal move") ||
2964 looking_at(buf, &i, "Your king is in check") ||
2965 looking_at(buf, &i, "It isn't your turn") ||
2966 looking_at(buf, &i, "It is not your move")) {
2968 if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
2969 currentMove = --forwardMostMove;
2970 DisplayMove(currentMove - 1); /* before DMError */
2971 DrawPosition(FALSE, boards[currentMove]);
2973 DisplayBothClocks();
2975 DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
2981 if (looking_at(buf, &i, "still have time") ||
2982 looking_at(buf, &i, "not out of time") ||
2983 looking_at(buf, &i, "either player is out of time") ||
2984 looking_at(buf, &i, "has timeseal; checking")) {
2985 /* We must have called his flag a little too soon */
2986 whiteFlag = blackFlag = FALSE;
2990 if (looking_at(buf, &i, "added * seconds to") ||
2991 looking_at(buf, &i, "seconds were added to")) {
2992 /* Update the clocks */
2993 SendToICS(ics_prefix);
2994 SendToICS("refresh\n");
2998 if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
2999 ics_clock_paused = TRUE;
3004 if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3005 ics_clock_paused = FALSE;
3010 /* Grab player ratings from the Creating: message.
3011 Note we have to check for the special case when
3012 the ICS inserts things like [white] or [black]. */
3013 if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3014 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3016 0 player 1 name (not necessarily white)
3018 2 empty, white, or black (IGNORED)
3019 3 player 2 name (not necessarily black)
3022 The names/ratings are sorted out when the game
3023 actually starts (below).
3025 strcpy(player1Name, StripHighlightAndTitle(star_match[0]));
3026 player1Rating = string_to_rating(star_match[1]);
3027 strcpy(player2Name, StripHighlightAndTitle(star_match[3]));
3028 player2Rating = string_to_rating(star_match[4]);
3030 if (appData.debugMode)
3032 "Ratings from 'Creating:' %s %d, %s %d\n",
3033 player1Name, player1Rating,
3034 player2Name, player2Rating);
3039 /* Improved generic start/end-of-game messages */
3040 if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
3041 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
3042 /* If tkind == 0: */
3043 /* star_match[0] is the game number */
3044 /* [1] is the white player's name */
3045 /* [2] is the black player's name */
3046 /* For end-of-game: */
3047 /* [3] is the reason for the game end */
3048 /* [4] is a PGN end game-token, preceded by " " */
3049 /* For start-of-game: */
3050 /* [3] begins with "Creating" or "Continuing" */
3051 /* [4] is " *" or empty (don't care). */
3052 int gamenum = atoi(star_match[0]);
3053 char *whitename, *blackname, *why, *endtoken;
3054 ChessMove endtype = (ChessMove) 0;
3057 whitename = star_match[1];
3058 blackname = star_match[2];
3059 why = star_match[3];
3060 endtoken = star_match[4];
3062 whitename = star_match[1];
3063 blackname = star_match[3];
3064 why = star_match[5];
3065 endtoken = star_match[6];
3068 /* Game start messages */
3069 if (strncmp(why, "Creating ", 9) == 0 ||
3070 strncmp(why, "Continuing ", 11) == 0) {
3071 gs_gamenum = gamenum;
3072 strcpy(gs_kind, strchr(why, ' ') + 1);
3074 if (appData.zippyPlay) {
3075 ZippyGameStart(whitename, blackname);
3081 /* Game end messages */
3082 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
3083 ics_gamenum != gamenum) {
3086 while (endtoken[0] == ' ') endtoken++;
3087 switch (endtoken[0]) {
3090 endtype = GameUnfinished;
3093 endtype = BlackWins;
3096 if (endtoken[1] == '/')
3097 endtype = GameIsDrawn;
3099 endtype = WhiteWins;
3102 GameEnds(endtype, why, GE_ICS);
3104 if (appData.zippyPlay && first.initDone) {
3105 ZippyGameEnd(endtype, why);
3106 if (first.pr == NULL) {
3107 /* Start the next process early so that we'll
3108 be ready for the next challenge */
3109 StartChessProgram(&first);
3111 /* Send "new" early, in case this command takes
3112 a long time to finish, so that we'll be ready
3113 for the next challenge. */
3114 gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
3121 if (looking_at(buf, &i, "Removing game * from observation") ||
3122 looking_at(buf, &i, "no longer observing game *") ||
3123 looking_at(buf, &i, "Game * (*) has no examiners")) {
3124 if (gameMode == IcsObserving &&
3125 atoi(star_match[0]) == ics_gamenum)
3127 /* icsEngineAnalyze */
3128 if (appData.icsEngineAnalyze) {
3135 ics_user_moved = FALSE;
3140 if (looking_at(buf, &i, "no longer examining game *")) {
3141 if (gameMode == IcsExamining &&
3142 atoi(star_match[0]) == ics_gamenum)
3146 ics_user_moved = FALSE;
3151 /* Advance leftover_start past any newlines we find,
3152 so only partial lines can get reparsed */
3153 if (looking_at(buf, &i, "\n")) {
3154 prevColor = curColor;
3155 if (curColor != ColorNormal) {
3156 if (oldi > next_out) {
3157 SendToPlayer(&buf[next_out], oldi - next_out);
3160 Colorize(ColorNormal, FALSE);
3161 curColor = ColorNormal;
3163 if (started == STARTED_BOARD) {
3164 started = STARTED_NONE;
3165 parse[parse_pos] = NULLCHAR;
3166 ParseBoard12(parse);
3169 /* Send premove here */
3170 if (appData.premove) {
3172 if (currentMove == 0 &&
3173 gameMode == IcsPlayingWhite &&
3174 appData.premoveWhite) {
3175 sprintf(str, "%s%s\n", ics_prefix,
3176 appData.premoveWhiteText);
3177 if (appData.debugMode)
3178 fprintf(debugFP, "Sending premove:\n");
3180 } else if (currentMove == 1 &&
3181 gameMode == IcsPlayingBlack &&
3182 appData.premoveBlack) {
3183 sprintf(str, "%s%s\n", ics_prefix,
3184 appData.premoveBlackText);
3185 if (appData.debugMode)
3186 fprintf(debugFP, "Sending premove:\n");
3188 } else if (gotPremove) {
3190 ClearPremoveHighlights();
3191 if (appData.debugMode)
3192 fprintf(debugFP, "Sending premove:\n");
3193 UserMoveEvent(premoveFromX, premoveFromY,
3194 premoveToX, premoveToY,
3199 /* Usually suppress following prompt */
3200 if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
3201 if (looking_at(buf, &i, "*% ")) {
3202 savingComment = FALSE;
3206 } else if (started == STARTED_HOLDINGS) {
3208 char new_piece[MSG_SIZ];
3209 started = STARTED_NONE;
3210 parse[parse_pos] = NULLCHAR;
3211 if (appData.debugMode)
3212 fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
3213 parse, currentMove);
3214 if (sscanf(parse, " game %d", &gamenum) == 1 &&
3215 gamenum == ics_gamenum) {
3216 if (gameInfo.variant == VariantNormal) {
3217 /* [HGM] We seem to switch variant during a game!
3218 * Presumably no holdings were displayed, so we have
3219 * to move the position two files to the right to
3220 * create room for them!
3222 VariantSwitch(boards[currentMove], VariantCrazyhouse); /* temp guess */
3223 /* Get a move list just to see the header, which
3224 will tell us whether this is really bug or zh */
3225 if (ics_getting_history == H_FALSE) {
3226 ics_getting_history = H_REQUESTED;
3227 sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3231 new_piece[0] = NULLCHAR;
3232 sscanf(parse, "game %d white [%s black [%s <- %s",
3233 &gamenum, white_holding, black_holding,
3235 white_holding[strlen(white_holding)-1] = NULLCHAR;
3236 black_holding[strlen(black_holding)-1] = NULLCHAR;
3237 /* [HGM] copy holdings to board holdings area */
3238 CopyHoldings(boards[currentMove], white_holding, WhitePawn);
3239 CopyHoldings(boards[currentMove], black_holding, BlackPawn);
3241 if (appData.zippyPlay && first.initDone) {
3242 ZippyHoldings(white_holding, black_holding,
3246 if (tinyLayout || smallLayout) {
3247 char wh[16], bh[16];
3248 PackHolding(wh, white_holding);
3249 PackHolding(bh, black_holding);
3250 sprintf(str, "[%s-%s] %s-%s", wh, bh,
3251 gameInfo.white, gameInfo.black);
3253 sprintf(str, "%s [%s] vs. %s [%s]",
3254 gameInfo.white, white_holding,
3255 gameInfo.black, black_holding);
3258 DrawPosition(FALSE, boards[currentMove]);
3261 /* Suppress following prompt */
3262 if (looking_at(buf, &i, "*% ")) {
3263 savingComment = FALSE;
3270 i++; /* skip unparsed character and loop back */
3273 if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz suppress printing in ICS interaction window
3274 started != STARTED_HOLDINGS && i > next_out) {
3275 SendToPlayer(&buf[next_out], i - next_out);
3278 suppressKibitz = FALSE; // [HGM] kibitz: has done its duty in if-statement above
3280 leftover_len = buf_len - leftover_start;
3281 /* if buffer ends with something we couldn't parse,
3282 reparse it after appending the next read */
3284 } else if (count == 0) {
3285 RemoveInputSource(isr);
3286 DisplayFatalError(_("Connection closed by ICS"), 0, 0);
3288 DisplayFatalError(_("Error reading from ICS"), error, 1);
3293 /* Board style 12 looks like this:
3295 <12> r-b---k- pp----pp ---bP--- ---p---- q------- ------P- P--Q--BP -----R-K W -1 0 0 0 0 0 0 paf MaxII 0 2 12 21 25 234 174 24 Q/d7-a4 (0:06) Qxa4 0 0
3297 * The "<12> " is stripped before it gets to this routine. The two
3298 * trailing 0's (flip state and clock ticking) are later addition, and
3299 * some chess servers may not have them, or may have only the first.
3300 * Additional trailing fields may be added in the future.
3303 #define PATTERN "%c%d%d%d%d%d%d%d%s%s%d%d%d%d%d%d%d%d%s%s%s%d%d"
3305 #define RELATION_OBSERVING_PLAYED 0
3306 #define RELATION_OBSERVING_STATIC -2 /* examined, oldmoves, or smoves */
3307 #define RELATION_PLAYING_MYMOVE 1
3308 #define RELATION_PLAYING_NOTMYMOVE -1
3309 #define RELATION_EXAMINING 2
3310 #define RELATION_ISOLATED_BOARD -3
3311 #define RELATION_STARTING_POSITION -4 /* FICS only */
3314 ParseBoard12(string)
3317 GameMode newGameMode;
3318 int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0, i;
3319 int j, k, n, moveNum, white_stren, black_stren, white_time, black_time, takeback;
3320 int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
3321 char to_play, board_chars[200];
3322 char move_str[500], str[500], elapsed_time[500];
3323 char black[32], white[32];
3325 int prevMove = currentMove;
3328 int fromX, fromY, toX, toY;
3330 int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
3331 char *bookHit = NULL; // [HGM] book
3333 fromX = fromY = toX = toY = -1;
3337 if (appData.debugMode)
3338 fprintf(debugFP, _("Parsing board: %s\n"), string);
3340 move_str[0] = NULLCHAR;
3341 elapsed_time[0] = NULLCHAR;
3342 { /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
3344 while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
3345 if(string[i] == ' ') { ranks++; files = 0; }
3349 for(j = 0; j <i; j++) board_chars[j] = string[j];
3350 board_chars[i] = '\0';
3353 n = sscanf(string, PATTERN, &to_play, &double_push,
3354 &castle_ws, &castle_wl, &castle_bs, &castle_bl, &irrev_count,
3355 &gamenum, white, black, &relation, &basetime, &increment,
3356 &white_stren, &black_stren, &white_time, &black_time,
3357 &moveNum, str, elapsed_time, move_str, &ics_flip,
3361 snprintf(str, sizeof(str), _("Failed to parse board string:\n\"%s\""), string);
3362 DisplayError(str, 0);
3366 /* Convert the move number to internal form */
3367 moveNum = (moveNum - 1) * 2;
3368 if (to_play == 'B') moveNum++;
3369 if (moveNum >= MAX_MOVES) {
3370 DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
3376 case RELATION_OBSERVING_PLAYED:
3377 case RELATION_OBSERVING_STATIC:
3378 if (gamenum == -1) {
3379 /* Old ICC buglet */
3380 relation = RELATION_OBSERVING_STATIC;
3382 newGameMode = IcsObserving;
3384 case RELATION_PLAYING_MYMOVE:
3385 case RELATION_PLAYING_NOTMYMOVE:
3387 ((relation == RELATION_PLAYING_MYMOVE) == (to_play == 'W')) ?
3388 IcsPlayingWhite : IcsPlayingBlack;
3390 case RELATION_EXAMINING:
3391 newGameMode = IcsExamining;
3393 case RELATION_ISOLATED_BOARD:
3395 /* Just display this board. If user was doing something else,
3396 we will forget about it until the next board comes. */
3397 newGameMode = IcsIdle;
3399 case RELATION_STARTING_POSITION:
3400 newGameMode = gameMode;
3404 /* Modify behavior for initial board display on move listing
3407 switch (ics_getting_history) {
3411 case H_GOT_REQ_HEADER:
3412 case H_GOT_UNREQ_HEADER:
3413 /* This is the initial position of the current game */
3414 gamenum = ics_gamenum;
3415 moveNum = 0; /* old ICS bug workaround */
3416 if (to_play == 'B') {
3417 startedFromSetupPosition = TRUE;
3418 blackPlaysFirst = TRUE;
3420 if (forwardMostMove == 0) forwardMostMove = 1;
3421 if (backwardMostMove == 0) backwardMostMove = 1;
3422 if (currentMove == 0) currentMove = 1;
3424 newGameMode = gameMode;
3425 relation = RELATION_STARTING_POSITION; /* ICC needs this */
3427 case H_GOT_UNWANTED_HEADER:
3428 /* This is an initial board that we don't want */
3430 case H_GETTING_MOVES:
3431 /* Should not happen */
3432 DisplayError(_("Error gathering move list: extra board"), 0);
3433 ics_getting_history = H_FALSE;
3437 /* Take action if this is the first board of a new game, or of a
3438 different game than is currently being displayed. */
3439 if (gamenum != ics_gamenum || newGameMode != gameMode ||
3440 relation == RELATION_ISOLATED_BOARD) {
3442 /* Forget the old game and get the history (if any) of the new one */
3443 if (gameMode != BeginningOfGame) {
3447 if (appData.autoRaiseBoard) BoardToTop();
3449 if (gamenum == -1) {
3450 newGameMode = IcsIdle;
3451 } else if (moveNum > 0 && newGameMode != IcsIdle &&
3452 appData.getMoveList) {
3453 /* Need to get game history */
3454 ics_getting_history = H_REQUESTED;
3455 sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3459 /* Initially flip the board to have black on the bottom if playing
3460 black or if the ICS flip flag is set, but let the user change
3461 it with the Flip View button. */
3462 flipView = appData.autoFlipView ?
3463 (newGameMode == IcsPlayingBlack) || ics_flip :
3466 /* Done with values from previous mode; copy in new ones */
3467 gameMode = newGameMode;
3469 ics_gamenum = gamenum;
3470 if (gamenum == gs_gamenum) {
3471 int klen = strlen(gs_kind);
3472 if (gs_kind[klen - 1] == '.') gs_kind[klen - 1] = NULLCHAR;
3473 sprintf(str, "ICS %s", gs_kind);
3474 gameInfo.event = StrSave(str);
3476 gameInfo.event = StrSave("ICS game");
3478 gameInfo.site = StrSave(appData.icsHost);
3479 gameInfo.date = PGNDate();
3480 gameInfo.round = StrSave("-");
3481 gameInfo.white = StrSave(white);
3482 gameInfo.black = StrSave(black);
3483 timeControl = basetime * 60 * 1000;
3485 timeIncrement = increment * 1000;
3486 movesPerSession = 0;
3487 gameInfo.timeControl = TimeControlTagValue();
3488 VariantSwitch(board, StringToVariant(gameInfo.event) );
3489 if (appData.debugMode) {
3490 fprintf(debugFP, "ParseBoard says variant = '%s'\n", gameInfo.event);
3491 fprintf(debugFP, "recognized as %s\n", VariantName(gameInfo.variant));
3492 setbuf(debugFP, NULL);
3495 gameInfo.outOfBook = NULL;
3497 /* Do we have the ratings? */
3498 if (strcmp(player1Name, white) == 0 &&
3499 strcmp(player2Name, black) == 0) {
3500 if (appData.debugMode)
3501 fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
3502 player1Rating, player2Rating);
3503 gameInfo.whiteRating = player1Rating;
3504 gameInfo.blackRating = player2Rating;
3505 } else if (strcmp(player2Name, white) == 0 &&
3506 strcmp(player1Name, black) == 0) {
3507 if (appData.debugMode)
3508 fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
3509 player2Rating, player1Rating);
3510 gameInfo.whiteRating = player2Rating;
3511 gameInfo.blackRating = player1Rating;
3513 player1Name[0] = player2Name[0] = NULLCHAR;
3515 /* Silence shouts if requested */
3516 if (appData.quietPlay &&
3517 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)) {
3518 SendToICS(ics_prefix);
3519 SendToICS("set shout 0\n");
3523 /* Deal with midgame name changes */
3525 if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
3526 if (gameInfo.white) free(gameInfo.white);
3527 gameInfo.white = StrSave(white);
3529 if (!gameInfo.black || strcmp(gameInfo.black, black) != 0) {
3530 if (gameInfo.black) free(gameInfo.black);
3531 gameInfo.black = StrSave(black);
3535 /* Throw away game result if anything actually changes in examine mode */
3536 if (gameMode == IcsExamining && !newGame) {
3537 gameInfo.result = GameUnfinished;
3538 if (gameInfo.resultDetails != NULL) {
3539 free(gameInfo.resultDetails);
3540 gameInfo.resultDetails = NULL;
3544 /* In pausing && IcsExamining mode, we ignore boards coming
3545 in if they are in a different variation than we are. */
3546 if (pauseExamInvalid) return;
3547 if (pausing && gameMode == IcsExamining) {
3548 if (moveNum <= pauseExamForwardMostMove) {
3549 pauseExamInvalid = TRUE;
3550 forwardMostMove = pauseExamForwardMostMove;
3555 if (appData.debugMode) {
3556 fprintf(debugFP, "load %dx%d board\n", files, ranks);
3558 /* Parse the board */
3559 for (k = 0; k < ranks; k++) {
3560 for (j = 0; j < files; j++)
3561 board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
3562 if(gameInfo.holdingsWidth > 1) {
3563 board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
3564 board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
3567 CopyBoard(boards[moveNum], board);
3569 startedFromSetupPosition =
3570 !CompareBoards(board, initialPosition);
3571 if(startedFromSetupPosition)
3572 initialRulePlies = irrev_count; /* [HGM] 50-move counter offset */
3575 /* [HGM] Set castling rights. Take the outermost Rooks,
3576 to make it also work for FRC opening positions. Note that board12
3577 is really defective for later FRC positions, as it has no way to
3578 indicate which Rook can castle if they are on the same side of King.
3579 For the initial position we grant rights to the outermost Rooks,
3580 and remember thos rights, and we then copy them on positions
3581 later in an FRC game. This means WB might not recognize castlings with
3582 Rooks that have moved back to their original position as illegal,
3583 but in ICS mode that is not its job anyway.
3585 if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
3586 { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
3588 for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
3589 if(board[0][i] == WhiteRook) j = i;
3590 initialRights[0] = castlingRights[moveNum][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3591 for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
3592 if(board[0][i] == WhiteRook) j = i;
3593 initialRights[1] = castlingRights[moveNum][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3594 for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
3595 if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
3596 initialRights[3] = castlingRights[moveNum][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3597 for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
3598 if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
3599 initialRights[4] = castlingRights[moveNum][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3601 if(gameInfo.variant == VariantKnightmate) { wKing = WhiteUnicorn; bKing = BlackUnicorn; }
3602 for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
3603 if(board[0][k] == wKing) initialRights[2] = castlingRights[moveNum][2] = k;
3604 for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
3605 if(board[BOARD_HEIGHT-1][k] == bKing)
3606 initialRights[5] = castlingRights[moveNum][5] = k;
3608 r = castlingRights[moveNum][0] = initialRights[0];
3609 if(board[0][r] != WhiteRook) castlingRights[moveNum][0] = -1;
3610 r = castlingRights[moveNum][1] = initialRights[1];
3611 if(board[0][r] != WhiteRook) castlingRights[moveNum][1] = -1;
3612 r = castlingRights[moveNum][3] = initialRights[3];
3613 if(board[BOARD_HEIGHT-1][r] != BlackRook) castlingRights[moveNum][3] = -1;
3614 r = castlingRights[moveNum][4] = initialRights[4];
3615 if(board[BOARD_HEIGHT-1][r] != BlackRook) castlingRights[moveNum][4] = -1;
3616 /* wildcastle kludge: always assume King has rights */
3617 r = castlingRights[moveNum][2] = initialRights[2];
3618 r = castlingRights[moveNum][5] = initialRights[5];
3620 /* [HGM] e.p. rights. Assume that ICS sends file number here? */
3621 epStatus[moveNum] = double_push == -1 ? EP_NONE : double_push + BOARD_LEFT;
3624 if (ics_getting_history == H_GOT_REQ_HEADER ||
3625 ics_getting_history == H_GOT_UNREQ_HEADER) {
3626 /* This was an initial position from a move list, not
3627 the current position */
3631 /* Update currentMove and known move number limits */
3632 newMove = newGame || moveNum > forwardMostMove;
3634 /* [DM] If we found takebacks during icsEngineAnalyze try send to engine */
3635 if (!newGame && appData.icsEngineAnalyze && moveNum < forwardMostMove) {
3636 takeback = forwardMostMove - moveNum;
3637 for (i = 0; i < takeback; i++) {
3638 if (appData.debugMode) fprintf(debugFP, "take back move\n");
3639 SendToProgram("undo\n", &first);
3644 forwardMostMove = backwardMostMove = currentMove = moveNum;
3645 if (gameMode == IcsExamining && moveNum == 0) {
3646 /* Workaround for ICS limitation: we are not told the wild
3647 type when starting to examine a game. But if we ask for
3648 the move list, the move list header will tell us */
3649 ics_getting_history = H_REQUESTED;
3650 sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3653 } else if (moveNum == forwardMostMove + 1 || moveNum == forwardMostMove
3654 || (moveNum < forwardMostMove && moveNum >= backwardMostMove)) {
3655 forwardMostMove = moveNum;
3656 if (!pausing || currentMove > forwardMostMove)
3657 currentMove = forwardMostMove;
3659 /* New part of history that is not contiguous with old part */
3660 if (pausing && gameMode == IcsExamining) {
3661 pauseExamInvalid = TRUE;
3662 forwardMostMove = pauseExamForwardMostMove;
3665 forwardMostMove = backwardMostMove = currentMove = moveNum;
3666 if (gameMode == IcsExamining && moveNum > 0 && appData.getMoveList) {
3667 ics_getting_history = H_REQUESTED;
3668 sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3673 /* Update the clocks */
3674 if (strchr(elapsed_time, '.')) {
3676 timeRemaining[0][moveNum] = whiteTimeRemaining = white_time;
3677 timeRemaining[1][moveNum] = blackTimeRemaining = black_time;
3679 /* Time is in seconds */
3680 timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
3681 timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
3686 if (appData.zippyPlay && newGame &&
3687 gameMode != IcsObserving && gameMode != IcsIdle &&
3688 gameMode != IcsExamining)
3689 ZippyFirstBoard(moveNum, basetime, increment);
3692 /* Put the move on the move list, first converting
3693 to canonical algebraic form. */
3695 if (appData.debugMode) {
3696 if (appData.debugMode) { int f = forwardMostMove;
3697 fprintf(debugFP, "parseboard %d, castling = %d %d %d %d %d %d\n", f,
3698 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
3700 fprintf(debugFP, "accepted move %s from ICS, parse it.\n", move_str);
3701 fprintf(debugFP, "moveNum = %d\n", moveNum);
3702 fprintf(debugFP, "board = %d-%d x %d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT);
3703 setbuf(debugFP, NULL);
3705 if (moveNum <= backwardMostMove) {
3706 /* We don't know what the board looked like before
3708 strcpy(parseList[moveNum - 1], move_str);
3709 strcat(parseList[moveNum - 1], " ");
3710 strcat(parseList[moveNum - 1], elapsed_time);
3711 moveList[moveNum - 1][0] = NULLCHAR;
3712 } else if (strcmp(move_str, "none") == 0) {
3713 // [HGM] long SAN: swapped order; test for 'none' before parsing move
3714 /* Again, we don't know what the board looked like;
3715 this is really the start of the game. */
3716 parseList[moveNum - 1][0] = NULLCHAR;
3717 moveList[moveNum - 1][0] = NULLCHAR;
3718 backwardMostMove = moveNum;
3719 startedFromSetupPosition = TRUE;
3720 fromX = fromY = toX = toY = -1;
3722 // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
3723 // So we parse the long-algebraic move string in stead of the SAN move
3724 int valid; char buf[MSG_SIZ], *prom;
3726 // str looks something like "Q/a1-a2"; kill the slash
3728 sprintf(buf, "%c%s", str[0], str+2);
3729 else strcpy(buf, str); // might be castling
3730 if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
3731 strcat(buf, prom); // long move lacks promo specification!
3732 if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
3733 if(appData.debugMode)
3734 fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
3735 strcpy(move_str, buf);
3737 valid = ParseOneMove(move_str, moveNum - 1, &moveType,
3738 &fromX, &fromY, &toX, &toY, &promoChar)
3739 || ParseOneMove(buf, moveNum - 1, &moveType,
3740 &fromX, &fromY, &toX, &toY, &promoChar);
3741 // end of long SAN patch
3743 (void) CoordsToAlgebraic(boards[moveNum - 1],
3744 PosFlags(moveNum - 1), EP_UNKNOWN,
3745 fromY, fromX, toY, toX, promoChar,
3746 parseList[moveNum-1]);
3747 switch (MateTest(boards[moveNum], PosFlags(moveNum), EP_UNKNOWN,
3748 castlingRights[moveNum]) ) {
3754 if(gameInfo.variant != VariantShogi)
3755 strcat(parseList[moveNum - 1], "+");
3758 case MT_STAINMATE: // [HGM] xq: for notation stalemate that wins counts as checkmate
3759 strcat(parseList[moveNum - 1], "#");
3762 strcat(parseList[moveNum - 1], " ");
3763 strcat(parseList[moveNum - 1], elapsed_time);
3764 /* currentMoveString is set as a side-effect of ParseOneMove */
3765 strcpy(moveList[moveNum - 1], currentMoveString);
3766 strcat(moveList[moveNum - 1], "\n");
3768 /* Move from ICS was illegal!? Punt. */
3769 if (appData.debugMode) {
3770 fprintf(debugFP, "Illegal move from ICS '%s'\n", move_str);
3771 fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
3773 strcpy(parseList[moveNum - 1], move_str);
3774 strcat(parseList[moveNum - 1], " ");
3775 strcat(parseList[moveNum - 1], elapsed_time);
3776 moveList[moveNum - 1][0] = NULLCHAR;
3777 fromX = fromY = toX = toY = -1;
3780 if (appData.debugMode) {
3781 fprintf(debugFP, "Move parsed to '%s'\n", parseList[moveNum - 1]);
3782 setbuf(debugFP, NULL);
3786 /* Send move to chess program (BEFORE animating it). */
3787 if (appData.zippyPlay && !newGame && newMove &&
3788 (!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
3790 if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
3791 (gameMode == IcsPlayingBlack && !WhiteOnMove(moveNum))) {
3792 if (moveList[moveNum - 1][0] == NULLCHAR) {
3793 sprintf(str, _("Couldn't parse move \"%s\" from ICS"),
3795 DisplayError(str, 0);
3797 if (first.sendTime) {
3798 SendTimeRemaining(&first, gameMode == IcsPlayingWhite);
3800 bookHit = SendMoveToBookUser(moveNum - 1, &first, FALSE); // [HGM] book
3801 if (firstMove && !bookHit) {
3803 if (first.useColors) {
3804 SendToProgram(gameMode == IcsPlayingWhite ?
3806 "black\ngo\n", &first);
3808 SendToProgram("go\n", &first);
3810 first.maybeThinking = TRUE;
3813 } else if (gameMode == IcsObserving || gameMode == IcsExamining) {
3814 if (moveList[moveNum - 1][0] == NULLCHAR) {
3815 sprintf(str, _("Couldn't parse move \"%s\" from ICS"), move_str);
3816 DisplayError(str, 0);