gtp.c

   1 #define DEBUG
   2 #include <assert.h>
   3 #include <ctype.h>
   4 #include <math.h>
   5 #include <stdarg.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <unistd.h>
  10
  11 #include "board.h"
  12 #include "debug.h"
  13 #include "engine.h"
  14 #include "fbook.h"
  15 #include "gtp.h"
  16 #include "mq.h"
  17 #include "uct/uct.h"
  18 #include "version.h"
  19 #include "timeinfo.h"
  20 #include "gogui.h"
  21
  22 #define NO_REPLY (-2)
  23
  24 /* Sleep 5 seconds after a game ends to give time to kill the program. */
  25 #define GAME_OVER_SLEEP 5
  26
  27 void
  28 gtp_prefix(char prefix, int id)
  29 {
  30         if (id == NO_REPLY) return;
  31         if (id >= 0)
  32                 printf("%c%d ", prefix, id);
  33         else
  34                 printf("%c ", prefix);
  35 }
  36
  37 void
  38 gtp_flush(void)
  39 {
  40         putchar('\n');
  41         fflush(stdout);
  42 }
  43
  44 void
  45 gtp_output(char prefix, int id, va_list params)
  46 {
  47         if (id == NO_REPLY) return;
  48         gtp_prefix(prefix, id);
  49         char *s;
  50         while ((s = va_arg(params, char *))) {
  51                 fputs(s, stdout);
  52         }
  53         putchar('\n');
  54         gtp_flush();
  55 }
  56
  57 void
  58 gtp_reply(int id, ...)
  59 {
  60         va_list params;
  61         va_start(params, id);
  62         gtp_output('=', id, params);
  63         va_end(params);
  64 }
  65
  66 void
  67 gtp_error(int id, ...)
  68 {
  69         va_list params;
  70         va_start(params, id);
  71         gtp_output('?', id, params);
  72         va_end(params);
  73 }
  74
  75 static void
  76 gtp_final_score(struct board *board, struct engine *engine, char *reply, int len)
  77 {
  78         struct move_queue q = { .moves = 0 };
  79         if (engine->dead_group_list)
  80                 engine->dead_group_list(engine, board, &q);
  81         floating_t score = board_official_score(board, &q);
  82         if (DEBUGL(1))
  83                 fprintf(stderr, "counted score %.1f\n", score);
  84         if (score == 0)
  85                 snprintf(reply, len, "0");
  86         else if (score > 0)
  87                 snprintf(reply, len, "W+%.1f", score);
  88         else
  89                 snprintf(reply, len, "B+%.1f", -score);
  90 }
  91
  92 /* List of known gtp commands. The internal command pachi-genmoves is not exported,
  93  * it should only be used between master and slaves of the distributed engine. */
  94 static char *known_commands_base =
  95         "protocol_version\n"
  96         "echo\n"
  97         "name\n"
  98         "version\n"
  99         "list_commands\n"
 100         "known_command\n"
 101         "quit\n"
 102         "boardsize\n"
 103         "clear_board\n"
 104         "kgs-game_over\n"
 105         "komi\n"
 106         "kgs-rules\n"
 107         "play\n"
 108         "genmove\n"
 109         "kgs-genmove_cleanup\n"
 110         "set_free_handicap\n"
 111         "place_free_handicap\n"
 112         "fixed_handicap\n"
 113         "final_score\n"
 114         "final_status_list\n"
 115         "undo\n"
 116         "pachi-evaluate\n"
 117         "pachi-result\n"
 118         "pachi-gentbook\n"
 119         "pachi-dumptbook\n"
 120         "pachi-predict\n"
 121         "kgs-chat\n"
 122         "time_left\n"
 123         "time_settings\n"
 124         "kgs-time_settings";
 125
 126 static char*
 127 known_commands(struct engine *engine)
 128 {
 129         static char *str = 0;
 130         if (str)
 131                 return str;
 132         if (strcmp(engine->name, "UCT"))  /* Not uct ? */
 133                 return known_commands_base;
 134         /* For now only uct supports gogui-analyze_commands */
 135         str = malloc(strlen(known_commands_base) + 32);
 136         sprintf(str, "%s\ngogui-analyze_commands", known_commands_base);
 137         return str;
 138 }
 139
 140 static char *gogui_analyze_commands =
 141         "string/          Final Score/final_score\n"
 142         "gfx/gfx   Best Moves B/gogui-best_moves b\n"
 143         "gfx/gfx   Best Moves W/gogui-best_moves w\n"
 144         "gfx/gfx   Winrates B/gogui-winrates b\n"
 145         "gfx/gfx   Winrates W/gogui-winrates w\n"
 146         "gfx/gfx   Owner Map/gogui-owner_map\n"
 147         "gfx/Live gfx = Best Moves/gogui-live_gfx best_moves\n"
 148         "gfx/Live gfx = Best Sequence/gogui-live_gfx best_seq\n"
 149         "gfx/Live gfx = Winrates/gogui-live_gfx winrates\n";
 150
 151
 152 char gogui_gfx_buf[5000];
 153 enum gogui_reporting gogui_live_gfx = 0;
 154
 155 static void
 156 gogui_set_live_gfx(struct engine *engine, char *arg)
 157 {
 158         if (!strcmp(arg, "best_moves"))
 159                 gogui_live_gfx = UR_GOGUI_CAN;
 160         if (!strcmp(arg, "best_seq"))
 161                 gogui_live_gfx = UR_GOGUI_SEQ;
 162         if (!strcmp(arg, "winrates"))
 163                 gogui_live_gfx = UR_GOGUI_WR;
 164         engine->live_gfx_hook(engine);
 165 }
 166
 167 static char *
 168 gogui_best_moves(struct board *b, struct engine *engine, char *arg, bool winrates)
 169 {
 170         enum stone color = str2stone(arg);
 171         assert(color != S_NONE);
 172         enum gogui_reporting prev = gogui_live_gfx;
 173         gogui_set_live_gfx(engine, (winrates ? "winrates" : "best_moves"));
 174         gogui_gfx_buf[0] = 0;
 175         engine->best_moves(engine, b, color);
 176         gogui_live_gfx = prev;
 177         return gogui_gfx_buf;
 178 }
 179
 180 /* XXX Completely unsafe if reply buffer is not big enough */
 181 static void
 182 gogui_owner_map(struct board *b, struct engine *engine, char *reply)
 183 {
 184         char str2[32];
 185         reply[0] = 0;
 186         if (!engine->owner_map)
 187                 return;
 188
 189         sprintf(reply, "INFLUENCE");
 190         foreach_point(b) {
 191                 if (board_at(b, c) == S_OFFBOARD)
 192                         continue;
 193                 float p = engine->owner_map(engine, b, c);
 194
 195                 // p = -1 for WHITE, 1 for BLACK absolute ownership of point i
 196                 if (p < -.8)
 197                         p = -1.0;
 198                 else if (p < -.5)
 199                         p = -0.7;
 200                 else if (p < -.2)
 201                         p = -0.4;
 202                 else if (p < 0.2)
 203                         p = 0.0;
 204                 else if (p < 0.5)
 205                         p = 0.4;
 206                 else if (p < 0.8)
 207                         p = 0.7;
 208                 else
 209                         p = 1.0;
 210                 sprintf(str2, " %3s %.1lf", coord2sstr(c, b), p);
 211                 strcat(reply, str2);
 212         } foreach_point_end;
 213
 214         strcat(reply, "\nTEXT Score Est: ");
 215         gtp_final_score(b, engine, str2, sizeof(str2));
 216         strcat(reply, str2);
 217 }
 218
 219 /* Return true if cmd is a valid gtp command. */
 220 bool
 221 gtp_is_valid(struct engine *e, const char *cmd)
 222 {
 223         if (!cmd || !*cmd) return false;
 224         const char *s = strcasestr(known_commands(e), cmd);
 225         if (!s) return false;
 226         if (s != known_commands(e) && s[-1] != '\n') return false;
 227
 228         int len = strlen(cmd);
 229         return s[len] == '\0' || s[len] == '\n';
 230 }
 231
 232 // For prediction stats
 233 static int played_games = 0;
 234
 235 static void
 236 gtp_predict_move(struct board *board, struct engine *engine, struct time_info *ti,
 237                  int id, struct move *m)
 238 {
 239         enum stone color = m->color;
 240
 241         if (m->coord == pass || m->coord == resign) {
 242                 int r = board_play(board, m);
 243                 assert(r >= 0);
 244                 gtp_reply(id, NULL);
 245                 return;
 246         }
 247
 248         if (DEBUGL(5))
 249                 fprintf(stderr, "predict move %d,%d,%d\n", m->color, coord_x(m->coord, board), coord_y(m->coord, board));
 250
 251         // Not bothering with timer here for now.
 252
 253         coord_t *c = engine->genmove(engine, board, &ti[color], color, 0);
 254
 255         // Hack to reset engine state (if it has one) in case engine
 256         // guessed wrong (engine expects us to play returned move)
 257         if (engine->undo)  // hackish way to reset state if engine needs it
 258                 engine->undo(engine, board);
 259
 260         // Play correct expected move
 261         if (board_play(board, m) < 0) {
 262                 fprintf(stderr, "ILLEGAL EXPECTED MOVE: [%s, %s]\n", coord2sstr(m->coord, board), stone2str(m->color));
 263                 abort();
 264         }
 265
 266         if (DEBUGL(1) && debug_boardprint)
 267                 engine_board_print(engine, board, stderr);
 268
 269         if (*c == m->coord)
 270                 fprintf(stderr, "Move %3i: Predict: Correctly predicted %s %s\n", board->moves,
 271                         (color == S_BLACK ? "b" : "w"), coord2sstr(*c, board));
 272         else
 273                 fprintf(stderr, "Move %3i: Predict: Wrong prediction: %s %s != %s\n", board->moves,
 274                         (color == S_BLACK ? "b" : "w"), coord2sstr(*c, board), coord2sstr(m->coord, board));
 275
 276         // Display stats from time to time
 277         {
 278                 static int total = 0;
 279                 static int guessed = 0;
 280                 guessed += (*c == m->coord);
 281                 if (++total % 200 == 0)
 282                         fprintf(stderr, "Predicted: %i/%i moves (%i%%)  games: %i\n",
 283                                 guessed, total, guessed * 100 / total, played_games);
 284         }
 285
 286         gtp_reply(id, NULL);
 287         coord_done(c);
 288 }
 289
 290
 291 /* XXX: THIS IS TOTALLY INSECURE!!!!
 292  * Even basic input checking is missing. */
 293
 294 enum parse_code
 295 gtp_parse(struct board *board, struct engine *engine, struct time_info *ti, char *buf)
 296 {
 297 #define next_tok(to_) \
 298         to_ = next; \
 299         next = next + strcspn(next, " \t\r\n"); \
 300         if (*next) { \
 301                 *next = 0; next++; \
 302                 next += strspn(next, " \t\r\n"); \
 303         }
 304
 305         if (strchr(buf, '#'))
 306                 *strchr(buf, '#') = 0;
 307
 308         char *cmd, *next = buf;
 309         next_tok(cmd);
 310
 311         int id = -1;
 312         if (isdigit(*cmd)) {
 313                 id = atoi(cmd);
 314                 next_tok(cmd);
 315         }
 316
 317         if (!*cmd)
 318                 return P_OK;
 319
 320         if (!strcasecmp(cmd, "protocol_version")) {
 321                 gtp_reply(id, "2", NULL);
 322                 return P_OK;
 323
 324         } else if (!strcasecmp(cmd, "name")) {
 325                 /* KGS hack */
 326                 gtp_reply(id, "Pachi ", engine->name, NULL);
 327                 return P_OK;
 328
 329         } else if (!strcasecmp(cmd, "echo")) {
 330                 gtp_reply(id, next, NULL);
 331                 return P_OK;
 332
 333         } else if (!strcasecmp(cmd, "version")) {
 334                 gtp_reply(id, PACHI_VERSION, ": ", engine->comment, " Have a nice game!", NULL);
 335                 return P_OK;
 336
 337         } else if (!strcasecmp(cmd, "list_commands")) {
 338                 gtp_reply(id, known_commands(engine), NULL);
 339                 return P_OK;
 340
 341         } else if (!strcasecmp(cmd, "known_command")) {
 342                 char *arg;
 343                 next_tok(arg);
 344                 if (gtp_is_valid(engine, arg)) {
 345                         gtp_reply(id, "true", NULL);
 346                 } else {
 347                         gtp_reply(id, "false", NULL);
 348                 }
 349                 return P_OK;
 350         }
 351
 352         if (engine->notify && gtp_is_valid(engine, cmd)) {
 353                 char *reply;
 354                 enum parse_code c = engine->notify(engine, board, id, cmd, next, &reply);
 355                 if (c == P_NOREPLY) {
 356                         id = NO_REPLY;
 357                 } else if (c == P_DONE_OK) {
 358                         gtp_reply(id, reply, NULL);
 359                         return P_OK;
 360                 } else if (c == P_DONE_ERROR) {
 361                         gtp_error(id, reply, NULL);
 362                         /* This is an internal error for the engine, but
 363                          * it is still OK from main's point of view. */
 364                         return P_OK;
 365                 } else if (c != P_OK) {
 366                         return c;
 367                 }
 368         }
 369
 370         if (!strcasecmp(cmd, "quit")) {
 371                 gtp_reply(id, NULL);
 372                 exit(0);
 373
 374         } else if (!strcasecmp(cmd, "boardsize")) {
 375                 char *arg;
 376                 next_tok(arg);
 377                 int size = atoi(arg);
 378                 if (size < 1 || size > BOARD_MAX_SIZE) {
 379                         gtp_error(id, "illegal board size", NULL);
 380                         return P_OK;
 381                 }
 382                 board_resize(board, size);
 383                 board_clear(board);
 384                 gtp_reply(id, NULL);
 385                 return P_ENGINE_RESET;
 386
 387         } else if (!strcasecmp(cmd, "clear_board")) {
 388                 board_clear(board);
 389                 played_games++;
 390                 if (DEBUGL(3) && debug_boardprint)
 391                         board_print(board, stderr);
 392                 gtp_reply(id, NULL);
 393                 return P_ENGINE_RESET;
 394
 395         } else if (!strcasecmp(cmd, "kgs-game_over")) {
 396                 /* The game may not be really over, just adjourned.
 397                  * Do not clear the board to avoid illegal moves
 398                  * if the game is resumed immediately after. KGS
 399                  * may start directly with genmove on resumption. */
 400                 if (DEBUGL(1)) {
 401                         fprintf(stderr, "game is over\n");
 402                         fflush(stderr);
 403                 }
 404                 if (engine->stop)
 405                         engine->stop(engine);
 406                 /* Sleep before replying, so that kgs doesn't
 407                  * start another game immediately. */
 408                 sleep(GAME_OVER_SLEEP);
 409                 gtp_reply(id, NULL);
 410
 411         } else if (!strcasecmp(cmd, "komi")) {
 412                 char *arg;
 413                 next_tok(arg);
 414                 sscanf(arg, PRIfloating, &board->komi);
 415
 416                 if (DEBUGL(3) && debug_boardprint)
 417                         board_print(board, stderr);
 418                 gtp_reply(id, NULL);
 419
 420         } else if (!strcasecmp(cmd, "kgs-rules")) {
 421                 char *arg;
 422                 next_tok(arg);
 423                 if (!board_set_rules(board, arg)) {
 424                         gtp_error(id, "unknown rules", NULL);
 425                         return P_OK;
 426                 }
 427                 gtp_reply(id, NULL);
 428
 429         } else if (!strcasecmp(cmd, "play")) {
 430                 struct move m;
 431
 432                 char *arg;
 433                 next_tok(arg);
 434                 m.color = str2stone(arg);
 435                 next_tok(arg);
 436                 coord_t *c = str2coord(arg, board_size(board));
 437                 m.coord = *c; coord_done(c);
 438                 next_tok(arg);
 439                 char *enginearg = arg;
 440                 char *reply = NULL;
 441
 442                 if (DEBUGL(5))
 443                         fprintf(stderr, "got move %d,%d,%d\n", m.color, coord_x(m.coord, board), coord_y(m.coord, board));
 444
 445                 // This is where kgs starts the timer, not at genmove!
 446                 time_start_timer(&ti[stone_other(m.color)]);
 447
 448                 if (engine->notify_play)
 449                         reply = engine->notify_play(engine, board, &m, enginearg);
 450                 if (board_play(board, &m) < 0) {
 451                         if (DEBUGL(0)) {
 452                                 fprintf(stderr, "! ILLEGAL MOVE %d,%d,%d\n", m.color, coord_x(m.coord, board), coord_y(m.coord, board));
 453                                 board_print(board, stderr);
 454                         }
 455                         gtp_error(id, "illegal move", NULL);
 456                 } else {
 457                         if (DEBUGL(4) && debug_boardprint)
 458                                 engine_board_print(engine, board, stderr);
 459                         gtp_reply(id, reply, NULL);
 460                 }
 461
 462         } else if (!strcasecmp(cmd, "pachi-predict")) {
 463                 struct move m;
 464                 char *arg;
 465                 next_tok(arg);
 466                 m.color = str2stone(arg);
 467                 next_tok(arg);
 468                 coord_t *c = str2coord(arg, board_size(board));
 469                 m.coord = *c; coord_done(c);
 470                 next_tok(arg);
 471
 472                 gtp_predict_move(board, engine, ti, id, &m);
 473
 474         } else if (!strcasecmp(cmd, "genmove") || !strcasecmp(cmd, "kgs-genmove_cleanup")) {
 475                 char *arg;
 476                 next_tok(arg);
 477                 enum stone color = str2stone(arg);
 478                 coord_t *c = NULL;
 479                 if (DEBUGL(2) && debug_boardprint)
 480                         engine_board_print(engine, board, stderr);
 481
 482                 if (!ti[color].len.t.timer_start) {
 483                         /* First game move. */
 484                         time_start_timer(&ti[color]);
 485                 }
 486
 487                 coord_t cf = pass;
 488                 if (board->fbook)
 489                         cf = fbook_check(board);
 490                 if (!is_pass(cf)) {
 491                         c = coord_copy(cf);
 492                 } else {
 493                         c = engine->genmove(engine, board, &ti[color], color, !strcasecmp(cmd, "kgs-genmove_cleanup"));
 494                 }
 495                 struct move m = { *c, color };
 496                 if (board_play(board, &m) < 0) {
 497                         fprintf(stderr, "Attempted to generate an illegal move: [%s, %s]\n", coord2sstr(m.coord, board), stone2str(m.color));
 498                         abort();
 499                 }
 500                 char *str = coord2str(*c, board);
 501                 if (DEBUGL(4))
 502                         fprintf(stderr, "playing move %s\n", str);
 503                 if (DEBUGL(1) && debug_boardprint) {
 504                         engine_board_print(engine, board, stderr);
 505                 }
 506                 gtp_reply(id, str, NULL);
 507                 free(str); coord_done(c);
 508
 509                 /* Account for spent time. If our GTP peer keeps our clock, this will
 510                  * be overriden by next time_left GTP command properly. */
 511                 /* (XXX: Except if we pass to byoyomi and the peer doesn't, but that
 512                  * should be absolutely rare situation and we will just spend a little
 513                  * less time than we could on next few moves.) */
 514                 if (ti[color].period != TT_NULL && ti[color].dim == TD_WALLTIME)
 515                         time_sub(&ti[color], time_now() - ti[color].len.t.timer_start, true);
 516
 517         } else if (!strcasecmp(cmd, "pachi-genmoves") || !strcasecmp(cmd, "pachi-genmoves_cleanup")) {
 518                 char *arg;
 519                 next_tok(arg);
 520                 enum stone color = str2stone(arg);
 521                 void *stats;
 522                 int stats_size;
 523
 524                 char *reply = engine->genmoves(engine, board, &ti[color], color, next,
 525                                                !strcasecmp(cmd, "pachi-genmoves_cleanup"),
 526                                                &stats, &stats_size);
 527                 if (!reply) {
 528                         gtp_error(id, "genmoves error", NULL);
 529                         return P_OK;
 530                 }
 531                 if (DEBUGL(3))
 532                         fprintf(stderr, "proposing moves %s\n", reply);
 533                 if (DEBUGL(4) && debug_boardprint)
 534                         engine_board_print(engine, board, stderr);
 535                 gtp_reply(id, reply, NULL);
 536                 if (stats_size > 0) {
 537                         double start = time_now();
 538                         fwrite(stats, 1, stats_size, stdout);
 539                         fflush(stdout);
 540                         if (DEBUGVV(2))
 541                                 fprintf(stderr, "sent reply %d bytes in %.4fms\n",
 542                                         stats_size, (time_now() - start)*1000);
 543                 }
 544
 545         } else if (!strcasecmp(cmd, "set_free_handicap")) {
 546                 struct move m;
 547                 m.color = S_BLACK;
 548
 549                 char *arg;
 550                 next_tok(arg);
 551                 do {
 552                         coord_t *c = str2coord(arg, board_size(board));
 553                         m.coord = *c; coord_done(c);
 554                         if (DEBUGL(4))
 555                                 fprintf(stderr, "setting handicap %d,%d\n", coord_x(m.coord, board), coord_y(m.coord, board));
 556
 557                         if (board_play(board, &m) < 0) {
 558                                 if (DEBUGL(0))
 559                                         fprintf(stderr, "! ILLEGAL MOVE %d,%d,%d\n", m.color, coord_x(m.coord, board), coord_y(m.coord, board));
 560                                 gtp_error(id, "illegal move", NULL);
 561                         }
 562                         board->handicap++;
 563                         next_tok(arg);
 564                 } while (*arg);
 565                 if (DEBUGL(1) && debug_boardprint)
 566                         board_print(board, stderr);
 567                 gtp_reply(id, NULL);
 568
 569         /* TODO: Engine should choose free handicap; however, it tends to take
 570          * overly long to think it all out, and unless it's clever its
 571          * handicap stones won't be of much help. ;-) */
 572         } else if (!strcasecmp(cmd, "place_free_handicap")
 573                   || !strcasecmp(cmd, "fixed_handicap")) {
 574                 char *arg;
 575                 next_tok(arg);
 576                 int stones = atoi(arg);
 577
 578                 gtp_prefix('=', id);
 579                 board_handicap(board, stones, id == NO_REPLY ? NULL : stdout);
 580                 if (DEBUGL(1) && debug_boardprint)
 581                         board_print(board, stderr);
 582                 if (id == NO_REPLY) return P_OK;
 583                 putchar('\n');
 584                 gtp_flush();
 585
 586         } else if (!strcasecmp(cmd, "final_score")) {
 587                 char str[64];
 588                 gtp_final_score(board, engine, str, sizeof(str));
 589                 gtp_reply(id, str, NULL);
 590
 591         /* XXX: This is a huge hack. */
 592         } else if (!strcasecmp(cmd, "final_status_list")) {
 593                 if (id == NO_REPLY) return P_OK;
 594                 char *arg;
 595                 next_tok(arg);
 596                 struct move_queue q = { .moves = 0 };
 597                 if (engine->dead_group_list)
 598                         engine->dead_group_list(engine, board, &q);
 599                 /* else we return empty list - i.e. engine not supporting
 600                  * this assumes all stones alive at the game end. */
 601                 if (!strcasecmp(arg, "dead")) {
 602                         gtp_prefix('=', id);
 603                         for (unsigned int i = 0; i < q.moves; i++) {
 604                                 foreach_in_group(board, q.move[i]) {
 605                                         printf("%s ", coord2sstr(c, board));
 606                                 } foreach_in_group_end;
 607                                 putchar('\n');
 608                         }
 609                         if (!q.moves)
 610                                 putchar('\n');
 611                         gtp_flush();
 612                 } else if (!strcasecmp(arg, "seki") || !strcasecmp(arg, "alive")) {
 613                         gtp_prefix('=', id);
 614                         bool printed_group = false;
 615                         foreach_point(board) { // foreach_group, effectively
 616                                 group_t g = group_at(board, c);
 617                                 if (!g || g != c) continue;
 618
 619                                 for (unsigned int i = 0; i < q.moves; i++) {
 620                                         if (q.move[i] == g)
 621                                                 goto next_group;
 622                                 }
 623                                 foreach_in_group(board, g) {
 624                                         printf("%s ", coord2sstr(c, board));
 625                                 } foreach_in_group_end;
 626                                 putchar('\n');
 627                                 printed_group = true;
 628 next_group:;
 629                         } foreach_point_end;
 630                         if (!printed_group)
 631                                 putchar('\n');
 632                         gtp_flush();
 633                 } else {
 634                         gtp_error(id, "illegal status specifier", NULL);
 635                 }
 636
 637         } else if (!strcasecmp(cmd, "undo")) {
 638                 if (board_undo(board) < 0) {
 639                         if (DEBUGL(1)) {
 640                                 fprintf(stderr, "undo on non-pass move %s\n", coord2sstr(board->last_move.coord, board));
 641                                 board_print(board, stderr);
 642                         }
 643                         gtp_error(id, "cannot undo", NULL);
 644                         return P_OK;
 645                 }
 646                 char *reply = NULL;
 647                 if (engine->undo)
 648                         reply = engine->undo(engine, board);
 649                 if (DEBUGL(3) && debug_boardprint)
 650                         board_print(board, stderr);
 651                 gtp_reply(id, reply, NULL);
 652
 653         /* Custom commands for handling the tree opening tbook */
 654         } else if (!strcasecmp(cmd, "pachi-gentbook")) {
 655                 /* Board must be initialized properly, as if for genmove;
 656                  * makes sense only as 'uct_gentbook b'. */
 657                 char *arg;
 658                 next_tok(arg);
 659                 enum stone color = str2stone(arg);
 660                 if (uct_gentbook(engine, board, &ti[color], color))
 661                         gtp_reply(id, NULL);
 662                 else
 663                         gtp_error(id, "error generating tbook", NULL);
 664
 665         } else if (!strcasecmp(cmd, "pachi-dumptbook")) {
 666                 char *arg;
 667                 next_tok(arg);
 668                 enum stone color = str2stone(arg);
 669                 uct_dumptbook(engine, board, color);
 670                 gtp_reply(id, NULL);
 671
 672         } else if (!strcasecmp(cmd, "pachi-evaluate")) {
 673                 char *arg;
 674                 next_tok(arg);
 675                 enum stone color = str2stone(arg);
 676
 677                 if (!engine->evaluate) {
 678                         gtp_error(id, "pachi-evaluate not supported by engine", NULL);
 679                 } else {
 680                         gtp_prefix('=', id);
 681                         floating_t vals[board->flen];
 682                         engine->evaluate(engine, board, &ti[color], vals, color);
 683                         for (int i = 0; i < board->flen; i++) {
 684                                 if (!board_coord_in_symmetry(board, board->f[i])
 685                                     || isnan(vals[i]) || vals[i] < 0.001)
 686                                         continue;
 687                                 printf("%s %.3f\n", coord2sstr(board->f[i], board), (double) vals[i]);
 688                         }
 689                         gtp_flush();
 690                 }
 691
 692         } else if (!strcasecmp(cmd, "pachi-result")) {
 693                 /* More detailed result of the last genmove. */
 694                 /* For UCT, the output format is: = color move playouts winrate dynkomi */
 695                 char *reply = NULL;
 696                 if (engine->result)
 697                         reply = engine->result(engine, board);
 698                 if (reply)
 699                         gtp_reply(id, reply, NULL);
 700                 else
 701                         gtp_error(id, "unknown pachi-result command", NULL);
 702
 703         } else if (!strcasecmp(cmd, "kgs-chat")) {
 704                 char *loc;
 705                 next_tok(loc);
 706                 bool opponent = !strcasecmp(loc, "game");
 707                 char *from;
 708                 next_tok(from);
 709                 char *msg = next;
 710                 msg += strspn(msg, " \n\t");
 711                 char *end = strchr(msg, '\n');
 712                 if (end) *end = '\0';
 713                 char *reply = NULL;
 714                 if (engine->chat) {
 715                         reply = engine->chat(engine, board, opponent, from, msg);
 716                 }
 717                 if (reply)
 718                         gtp_reply(id, reply, NULL);
 719                 else
 720                         gtp_error(id, "unknown kgs-chat command", NULL);
 721
 722         } else if (!strcasecmp(cmd, "time_left")) {
 723                 char *arg;
 724                 next_tok(arg);
 725                 enum stone color = str2stone(arg);
 726                 next_tok(arg);
 727                 int time = atoi(arg);
 728                 next_tok(arg);
 729                 int stones = atoi(arg);
 730                 if (!ti[color].ignore_gtp) {
 731                         time_left(&ti[color], time, stones);
 732                 } else {
 733                         if (DEBUGL(2)) fprintf(stderr, "ignored time info\n");
 734                 }
 735
 736                 gtp_reply(id, NULL);
 737
 738         } else if (!strcasecmp(cmd, "time_settings") || !strcasecmp(cmd, "kgs-time_settings")) {
 739                 char *time_system;
 740                 char *arg;
 741                 if (!strcasecmp(cmd, "kgs-time_settings")) {
 742                         next_tok(time_system);
 743                 } else {
 744                         time_system = "canadian";
 745                 }
 746
 747                 int main_time = 0, byoyomi_time = 0, byoyomi_stones = 0, byoyomi_periods = 0;
 748                 if (!strcasecmp(time_system, "none")) {
 749                         main_time = -1;
 750                 } else if (!strcasecmp(time_system, "absolute")) {
 751                         next_tok(arg);
 752                         main_time = atoi(arg);
 753                 } else if (!strcasecmp(time_system, "byoyomi")) {
 754                         next_tok(arg);
 755                         main_time = atoi(arg);
 756                         next_tok(arg);
 757                         byoyomi_time = atoi(arg);
 758                         next_tok(arg);
 759                         byoyomi_periods = atoi(arg);
 760                 } else if (!strcasecmp(time_system, "canadian")) {
 761                         next_tok(arg);
 762                         main_time = atoi(arg);
 763                         next_tok(arg);
 764                         byoyomi_time = atoi(arg);
 765                         next_tok(arg);
 766                         byoyomi_stones = atoi(arg);
 767                 }
 768
 769                 if (DEBUGL(1))
 770                         fprintf(stderr, "time_settings %d %d/%d*%d\n",
 771                                 main_time, byoyomi_time, byoyomi_stones, byoyomi_periods);
 772                 if (!ti[S_BLACK].ignore_gtp) {
 773                         time_settings(&ti[S_BLACK], main_time, byoyomi_time, byoyomi_stones, byoyomi_periods);
 774                         ti[S_WHITE] = ti[S_BLACK];
 775                 } else {
 776                         if (DEBUGL(1)) fprintf(stderr, "ignored time info\n");
 777                 }
 778
 779                 gtp_reply(id, NULL);
 780
 781         } else if (!strcasecmp(cmd, "gogui-analyze_commands")) {
 782                 gtp_reply(id, gogui_analyze_commands, NULL);
 783         } else if (!strcasecmp(cmd, "gogui-live_gfx")) {
 784                 char *arg;
 785                 next_tok(arg);
 786                 gogui_set_live_gfx(engine, arg);
 787                 gtp_reply(id, NULL);
 788         } else if (!strcasecmp(cmd, "gogui-owner_map")) {
 789                 char reply[5000];
 790                 gogui_owner_map(board, engine, reply);
 791                 gtp_reply(id, reply, NULL);
 792         } else if (!strcasecmp(cmd, "gogui-best_moves")) {
 793                 char *arg;
 794                 next_tok(arg);
 795                 char *reply = gogui_best_moves(board, engine, arg, false);
 796                 gtp_reply(id, reply, NULL);
 797         } else if (!strcasecmp(cmd, "gogui-winrates")) {
 798                 char *arg;
 799                 next_tok(arg);
 800                 char *reply = gogui_best_moves(board, engine, arg, true);
 801                 gtp_reply(id, reply, NULL);
 802
 803         } else {
 804                 gtp_error(id, "unknown command", NULL);
 805                 return P_UNKNOWN_COMMAND;
 806         }
 807         return P_OK;
 808
 809 #undef next_tok
 810 }