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
  21 #define NO_REPLY (-2)
  22
  23 /* Sleep 5 seconds after a game ends to give time to kill the program. */
  24 #define GAME_OVER_SLEEP 5
  25
  26 void
  27 gtp_prefix(char prefix, int id)
  28 {
  29         if (id == NO_REPLY) return;
  30         if (id >= 0)
  31                 printf("%c%d ", prefix, id);
  32         else
  33                 printf("%c ", prefix);
  34 }
  35
  36 void
  37 gtp_flush(void)
  38 {
  39         putchar('\n');
  40         fflush(stdout);
  41 }
  42
  43 void
  44 gtp_output(char prefix, int id, va_list params)
  45 {
  46         if (id == NO_REPLY) return;
  47         gtp_prefix(prefix, id);
  48         char *s;
  49         while ((s = va_arg(params, char *))) {
  50                 fputs(s, stdout);
  51         }
  52         putchar('\n');
  53         gtp_flush();
  54 }
  55
  56 void
  57 gtp_reply(int id, ...)
  58 {
  59         va_list params;
  60         va_start(params, id);
  61         gtp_output('=', id, params);
  62         va_end(params);
  63 }
  64
  65 void
  66 gtp_error(int id, ...)
  67 {
  68         va_list params;
  69         va_start(params, id);
  70         gtp_output('?', id, params);
  71         va_end(params);
  72 }
  73
  74 /* List of known gtp commands. The internal command pachi-genmoves is not exported,
  75  * it should only be used between master and slaves of the distributed engine. */
  76 static char *known_commands =
  77         "protocol_version\n"
  78         "echo\n"
  79         "name\n"
  80         "version\n"
  81         "list_commands\n"
  82         "known_command\n"
  83         "quit\n"
  84         "boardsize\n"
  85         "clear_board\n"
  86         "kgs-game_over\n"
  87         "komi\n"
  88         "kgs-rules\n"
  89         "play\n"
  90         "genmove\n"
  91         "kgs-genmove_cleanup\n"
  92         "set_free_handicap\n"
  93         "place_free_handicap\n"
  94         "fixed_handicap\n"
  95         "final_score\n"
  96         "final_status_list\n"
  97         "undo\n"
  98         "pachi-evaluate\n"
  99         "pachi-result\n"
 100         "pachi-gentbook\n"
 101         "pachi-dumptbook\n"
 102         "kgs-chat\n"
 103         "time_left\n"
 104         "time_settings\n"
 105         "kgs-time_settings";
 106
 107
 108 /* Return true if cmd is a valid gtp command. */
 109 bool
 110 gtp_is_valid(const char *cmd)
 111 {
 112         if (!cmd || !*cmd) return false;
 113         const char *s = strcasestr(known_commands, cmd);
 114         if (!s) return false;
 115         if (s != known_commands && s[-1] != '\n') return false;
 116
 117         int len = strlen(cmd);
 118         return s[len] == '\0' || s[len] == '\n';
 119 }
 120
 121 /* XXX: THIS IS TOTALLY INSECURE!!!!
 122  * Even basic input checking is missing. */
 123
 124 enum parse_code
 125 gtp_parse(struct board *board, struct engine *engine, struct time_info *ti, char *buf)
 126 {
 127 #define next_tok(to_) \
 128         to_ = next; \
 129         next = next + strcspn(next, " \t\r\n"); \
 130         if (*next) { \
 131                 *next = 0; next++; \
 132                 next += strspn(next, " \t\r\n"); \
 133         }
 134
 135         if (strchr(buf, '#'))
 136                 *strchr(buf, '#') = 0;
 137
 138         char *cmd, *next = buf;
 139         next_tok(cmd);
 140
 141         int id = -1;
 142         if (isdigit(*cmd)) {
 143                 id = atoi(cmd);
 144                 next_tok(cmd);
 145         }
 146
 147         if (!*cmd)
 148                 return P_OK;
 149
 150         if (!strcasecmp(cmd, "protocol_version")) {
 151                 gtp_reply(id, "2", NULL);
 152                 return P_OK;
 153
 154         } else if (!strcasecmp(cmd, "name")) {
 155                 /* KGS hack */
 156                 gtp_reply(id, "Pachi ", engine->name, NULL);
 157                 return P_OK;
 158
 159         } else if (!strcasecmp(cmd, "echo")) {
 160                 gtp_reply(id, next, NULL);
 161                 return P_OK;
 162
 163         } else if (!strcasecmp(cmd, "version")) {
 164                 gtp_reply(id, PACHI_VERSION, ": ", engine->comment, " Have a nice game!", NULL);
 165                 return P_OK;
 166
 167         } else if (!strcasecmp(cmd, "list_commands")) {
 168                 gtp_reply(id, known_commands, NULL);
 169                 return P_OK;
 170
 171         } else if (!strcasecmp(cmd, "known_command")) {
 172                 char *arg;
 173                 next_tok(arg);
 174                 if (gtp_is_valid(arg)) {
 175                         gtp_reply(id, "true", NULL);
 176                 } else {
 177                         gtp_reply(id, "false", NULL);
 178                 }
 179                 return P_OK;
 180         }
 181
 182         if (engine->notify && gtp_is_valid(cmd)) {
 183                 char *reply;
 184                 enum parse_code c = engine->notify(engine, board, id, cmd, next, &reply);
 185                 if (c == P_NOREPLY) {
 186                         id = NO_REPLY;
 187                 } else if (c == P_DONE_OK) {
 188                         gtp_reply(id, reply, NULL);
 189                         return P_OK;
 190                 } else if (c == P_DONE_ERROR) {
 191                         gtp_error(id, reply, NULL);
 192                         /* This is an internal error for the engine, but
 193                          * it is still OK from main's point of view. */
 194                         return P_OK;
 195                 } else if (c != P_OK) {
 196                         return c;
 197                 }
 198         }
 199
 200         if (!strcasecmp(cmd, "quit")) {
 201                 gtp_reply(id, NULL);
 202                 exit(0);
 203
 204         } else if (!strcasecmp(cmd, "boardsize")) {
 205                 char *arg;
 206                 next_tok(arg);
 207                 int size = atoi(arg);
 208                 if (size < 1 || size > BOARD_MAX_SIZE) {
 209                         gtp_error(id, "illegal board size", NULL);
 210                         return P_OK;
 211                 }
 212                 board_resize(board, size);
 213                 board_clear(board);
 214                 gtp_reply(id, NULL);
 215                 return P_ENGINE_RESET;
 216
 217         } else if (!strcasecmp(cmd, "clear_board")) {
 218                 board_clear(board);
 219                 if (DEBUGL(3) && debug_boardprint)
 220                         board_print(board, stderr);
 221                 gtp_reply(id, NULL);
 222                 return P_ENGINE_RESET;
 223
 224         } else if (!strcasecmp(cmd, "kgs-game_over")) {
 225                 /* The game may not be really over, just adjourned.
 226                  * Do not clear the board to avoid illegal moves
 227                  * if the game is resumed immediately after. KGS
 228                  * may start directly with genmove on resumption. */
 229                 if (DEBUGL(1)) {
 230                         fprintf(stderr, "game is over\n");
 231                         fflush(stderr);
 232                 }
 233                 if (engine->stop)
 234                         engine->stop(engine);
 235                 /* Sleep before replying, so that kgs doesn't
 236                  * start another game immediately. */
 237                 sleep(GAME_OVER_SLEEP);
 238                 gtp_reply(id, NULL);
 239
 240         } else if (!strcasecmp(cmd, "komi")) {
 241                 char *arg;
 242                 next_tok(arg);
 243                 sscanf(arg, PRIfloating, &board->komi);
 244
 245                 if (DEBUGL(3) && debug_boardprint)
 246                         board_print(board, stderr);
 247                 gtp_reply(id, NULL);
 248
 249         } else if (!strcasecmp(cmd, "kgs-rules")) {
 250                 char *arg;
 251                 next_tok(arg);
 252                 if (!board_set_rules(board, arg)) {
 253                         gtp_error(id, "unknown rules", NULL);
 254                         return P_OK;
 255                 }
 256                 gtp_reply(id, NULL);
 257
 258         } else if (!strcasecmp(cmd, "play")) {
 259                 struct move m;
 260
 261                 char *arg;
 262                 next_tok(arg);
 263                 m.color = str2stone(arg);
 264                 next_tok(arg);
 265                 coord_t *c = str2coord(arg, board_size(board));
 266                 m.coord = *c; coord_done(c);
 267                 next_tok(arg);
 268                 char *enginearg = arg;
 269                 char *reply = NULL;
 270
 271                 if (DEBUGL(5))
 272                         fprintf(stderr, "got move %d,%d,%d\n", m.color, coord_x(m.coord, board), coord_y(m.coord, board));
 273
 274                 // This is where kgs starts the timer, not at genmove!
 275                 time_start_timer(&ti[stone_other(m.color)]);
 276
 277                 if (engine->notify_play)
 278                         reply = engine->notify_play(engine, board, &m, enginearg);
 279                 if (board_play(board, &m) < 0) {
 280                         if (DEBUGL(0)) {
 281                                 fprintf(stderr, "! ILLEGAL MOVE %d,%d,%d\n", m.color, coord_x(m.coord, board), coord_y(m.coord, board));
 282                                 board_print(board, stderr);
 283                         }
 284                         gtp_error(id, "illegal move", NULL);
 285                 } else {
 286                         if (DEBUGL(4) && debug_boardprint)
 287                                 board_print_custom(board, stderr, engine->printhook);
 288                         gtp_reply(id, reply, NULL);
 289                 }
 290
 291         } else if (!strcasecmp(cmd, "genmove") || !strcasecmp(cmd, "kgs-genmove_cleanup")) {
 292                 char *arg;
 293                 next_tok(arg);
 294                 enum stone color = str2stone(arg);
 295                 coord_t *c = NULL;
 296                 if (DEBUGL(2) && debug_boardprint)
 297                         board_print_custom(board, stderr, engine->printhook);
 298
 299                 if (!ti[color].len.t.timer_start) {
 300                         /* First game move. */
 301                         time_start_timer(&ti[color]);
 302                 }
 303
 304                 coord_t cf = pass;
 305                 if (board->fbook)
 306                         cf = fbook_check(board);
 307                 if (!is_pass(cf)) {
 308                         c = coord_copy(cf);
 309                 } else {
 310                         c = engine->genmove(engine, board, &ti[color], color, !strcasecmp(cmd, "kgs-genmove_cleanup"));
 311                 }
 312                 struct move m = { *c, color };
 313                 if (board_play(board, &m) < 0) {
 314                         fprintf(stderr, "Attempted to generate an illegal move: [%s, %s]\n", coord2sstr(m.coord, board), stone2str(m.color));
 315                         abort();
 316                 }
 317                 char *str = coord2str(*c, board);
 318                 if (DEBUGL(4))
 319                         fprintf(stderr, "playing move %s\n", str);
 320                 if (DEBUGL(1) && debug_boardprint) {
 321                         board_print_custom(board, stderr, engine->printhook);
 322                 }
 323                 gtp_reply(id, str, NULL);
 324                 free(str); coord_done(c);
 325
 326                 /* Account for spent time. If our GTP peer keeps our clock, this will
 327                  * be overriden by next time_left GTP command properly. */
 328                 /* (XXX: Except if we pass to byoyomi and the peer doesn't, but that
 329                  * should be absolutely rare situation and we will just spend a little
 330                  * less time than we could on next few moves.) */
 331                 if (ti[color].period != TT_NULL && ti[color].dim == TD_WALLTIME)
 332                         time_sub(&ti[color], time_now() - ti[color].len.t.timer_start, true);
 333
 334         } else if (!strcasecmp(cmd, "pachi-genmoves") || !strcasecmp(cmd, "pachi-genmoves_cleanup")) {
 335                 char *arg;
 336                 next_tok(arg);
 337                 enum stone color = str2stone(arg);
 338                 void *stats;
 339                 int stats_size;
 340
 341                 char *reply = engine->genmoves(engine, board, &ti[color], color, next,
 342                                                !strcasecmp(cmd, "pachi-genmoves_cleanup"),
 343                                                &stats, &stats_size);
 344                 if (!reply) {
 345                         gtp_error(id, "genmoves error", NULL);
 346                         return P_OK;
 347                 }
 348                 if (DEBUGL(3))
 349                         fprintf(stderr, "proposing moves %s\n", reply);
 350                 if (DEBUGL(4) && debug_boardprint)
 351                         board_print_custom(board, stderr, engine->printhook);
 352                 gtp_reply(id, reply, NULL);
 353                 if (stats_size > 0) {
 354                         double start = time_now();
 355                         fwrite(stats, 1, stats_size, stdout);
 356                         fflush(stdout);
 357                         if (DEBUGVV(2))
 358                                 fprintf(stderr, "sent reply %d bytes in %.4fms\n",
 359                                         stats_size, (time_now() - start)*1000);
 360                 }
 361
 362         } else if (!strcasecmp(cmd, "set_free_handicap")) {
 363                 struct move m;
 364                 m.color = S_BLACK;
 365
 366                 char *arg;
 367                 next_tok(arg);
 368                 do {
 369                         coord_t *c = str2coord(arg, board_size(board));
 370                         m.coord = *c; coord_done(c);
 371                         if (DEBUGL(4))
 372                                 fprintf(stderr, "setting handicap %d,%d\n", coord_x(m.coord, board), coord_y(m.coord, board));
 373
 374                         if (board_play(board, &m) < 0) {
 375                                 if (DEBUGL(0))
 376                                         fprintf(stderr, "! ILLEGAL MOVE %d,%d,%d\n", m.color, coord_x(m.coord, board), coord_y(m.coord, board));
 377                                 gtp_error(id, "illegal move", NULL);
 378                         }
 379                         board->handicap++;
 380                         next_tok(arg);
 381                 } while (*arg);
 382                 if (DEBUGL(1) && debug_boardprint)
 383                         board_print(board, stderr);
 384                 gtp_reply(id, NULL);
 385
 386         /* TODO: Engine should choose free handicap; however, it tends to take
 387          * overly long to think it all out, and unless it's clever its
 388          * handicap stones won't be of much help. ;-) */
 389         } else if (!strcasecmp(cmd, "place_free_handicap")
 390                   || !strcasecmp(cmd, "fixed_handicap")) {
 391                 char *arg;
 392                 next_tok(arg);
 393                 int stones = atoi(arg);
 394
 395                 gtp_prefix('=', id);
 396                 board_handicap(board, stones, id == NO_REPLY ? NULL : stdout);
 397                 if (DEBUGL(1) && debug_boardprint)
 398                         board_print(board, stderr);
 399                 if (id == NO_REPLY) return P_OK;
 400                 putchar('\n');
 401                 gtp_flush();
 402
 403         } else if (!strcasecmp(cmd, "final_score")) {
 404                 struct move_queue q = { .moves = 0 };
 405                 if (engine->dead_group_list)
 406                         engine->dead_group_list(engine, board, &q);
 407                 floating_t score = board_official_score(board, &q);
 408                 char str[64];
 409                 if (DEBUGL(1))
 410                         fprintf(stderr, "counted score %.1f\n", score);
 411                 if (score == 0) {
 412                         gtp_reply(id, "0", NULL);
 413                 } else if (score > 0) {
 414                         snprintf(str, 64, "W+%.1f", score);
 415                         gtp_reply(id, str, NULL);
 416                 } else {
 417                         snprintf(str, 64, "B+%.1f", -score);
 418                         gtp_reply(id, str, NULL);
 419                 }
 420
 421         /* XXX: This is a huge hack. */
 422         } else if (!strcasecmp(cmd, "final_status_list")) {
 423                 if (id == NO_REPLY) return P_OK;
 424                 char *arg;
 425                 next_tok(arg);
 426                 struct move_queue q = { .moves = 0 };
 427                 if (engine->dead_group_list)
 428                         engine->dead_group_list(engine, board, &q);
 429                 /* else we return empty list - i.e. engine not supporting
 430                  * this assumes all stones alive at the game end. */
 431                 if (!strcasecmp(arg, "dead")) {
 432                         gtp_prefix('=', id);
 433                         for (unsigned int i = 0; i < q.moves; i++) {
 434                                 foreach_in_group(board, q.move[i]) {
 435                                         printf("%s ", coord2sstr(c, board));
 436                                 } foreach_in_group_end;
 437                                 putchar('\n');
 438                         }
 439                         if (!q.moves)
 440                                 putchar('\n');
 441                         gtp_flush();
 442                 } else if (!strcasecmp(arg, "seki") || !strcasecmp(arg, "alive")) {
 443                         gtp_prefix('=', id);
 444                         bool printed_group = false;
 445                         foreach_point(board) { // foreach_group, effectively
 446                                 group_t g = group_at(board, c);
 447                                 if (!g || g != c) continue;
 448
 449                                 for (unsigned int i = 0; i < q.moves; i++) {
 450                                         if (q.move[i] == g)
 451                                                 goto next_group;
 452                                 }
 453                                 foreach_in_group(board, g) {
 454                                         printf("%s ", coord2sstr(c, board));
 455                                 } foreach_in_group_end;
 456                                 putchar('\n');
 457                                 printed_group = true;
 458 next_group:;
 459                         } foreach_point_end;
 460                         if (!printed_group)
 461                                 putchar('\n');
 462                         gtp_flush();
 463                 } else {
 464                         gtp_error(id, "illegal status specifier", NULL);
 465                 }
 466
 467         } else if (!strcasecmp(cmd, "undo")) {
 468                 if (board_undo(board) < 0) {
 469                         if (DEBUGL(1)) {
 470                                 fprintf(stderr, "undo on non-pass move %s\n", coord2sstr(board->last_move.coord, board));
 471                                 board_print(board, stderr);
 472                         }
 473                         gtp_error(id, "cannot undo", NULL);
 474                         return P_OK;
 475                 }
 476                 char *reply = NULL;
 477                 if (engine->undo)
 478                         reply = engine->undo(engine, board);
 479                 if (DEBUGL(3) && debug_boardprint)
 480                         board_print(board, stderr);
 481                 gtp_reply(id, reply, NULL);
 482
 483         /* Custom commands for handling the tree opening tbook */
 484         } else if (!strcasecmp(cmd, "pachi-gentbook")) {
 485                 /* Board must be initialized properly, as if for genmove;
 486                  * makes sense only as 'uct_gentbook b'. */
 487                 char *arg;
 488                 next_tok(arg);
 489                 enum stone color = str2stone(arg);
 490                 if (uct_gentbook(engine, board, &ti[color], color))
 491                         gtp_reply(id, NULL);
 492                 else
 493                         gtp_error(id, "error generating tbook", NULL);
 494
 495         } else if (!strcasecmp(cmd, "pachi-dumptbook")) {
 496                 char *arg;
 497                 next_tok(arg);
 498                 enum stone color = str2stone(arg);
 499                 uct_dumptbook(engine, board, color);
 500                 gtp_reply(id, NULL);
 501
 502         } else if (!strcasecmp(cmd, "pachi-evaluate")) {
 503                 char *arg;
 504                 next_tok(arg);
 505                 enum stone color = str2stone(arg);
 506
 507                 if (!engine->evaluate) {
 508                         gtp_error(id, "pachi-evaluate not supported by engine", NULL);
 509                 } else {
 510                         gtp_prefix('=', id);
 511                         floating_t vals[board->flen];
 512                         engine->evaluate(engine, board, &ti[color], vals, color);
 513                         for (int i = 0; i < board->flen; i++) {
 514                                 if (!board_coord_in_symmetry(board, board->f[i])
 515                                     || isnan(vals[i]) || vals[i] < 0.001)
 516                                         continue;
 517                                 printf("%s %.3f\n", coord2sstr(board->f[i], board), (double) vals[i]);
 518                         }
 519                         gtp_flush();
 520                 }
 521
 522         } else if (!strcasecmp(cmd, "pachi-result")) {
 523                 /* More detailed result of the last genmove. */
 524                 /* For UCT, the output format is: = color move playouts winrate dynkomi */
 525                 char *reply = NULL;
 526                 if (engine->result)
 527                         reply = engine->result(engine, board);
 528                 if (reply)
 529                         gtp_reply(id, reply, NULL);
 530                 else
 531                         gtp_error(id, "unknown pachi-result command", NULL);
 532
 533         } else if (!strcasecmp(cmd, "kgs-chat")) {
 534                 char *loc;
 535                 next_tok(loc);
 536                 bool opponent = !strcasecmp(loc, "game");
 537                 char *from;
 538                 next_tok(from);
 539                 char *msg = next;
 540                 msg += strspn(msg, " \n\t");
 541                 char *end = strchr(msg, '\n');
 542                 if (end) *end = '\0';
 543                 char *reply = NULL;
 544                 if (engine->chat) {
 545                         reply = engine->chat(engine, board, opponent, from, msg);
 546                 }
 547                 if (reply)
 548                         gtp_reply(id, reply, NULL);
 549                 else
 550                         gtp_error(id, "unknown kgs-chat command", NULL);
 551
 552         } else if (!strcasecmp(cmd, "time_left")) {
 553                 char *arg;
 554                 next_tok(arg);
 555                 enum stone color = str2stone(arg);
 556                 next_tok(arg);
 557                 int time = atoi(arg);
 558                 next_tok(arg);
 559                 int stones = atoi(arg);
 560                 if (!ti[color].ignore_gtp) {
 561                         time_left(&ti[color], time, stones);
 562                 } else {
 563                         if (DEBUGL(2)) fprintf(stderr, "ignored time info\n");
 564                 }
 565
 566                 gtp_reply(id, NULL);
 567
 568         } else if (!strcasecmp(cmd, "time_settings") || !strcasecmp(cmd, "kgs-time_settings")) {
 569                 char *time_system;
 570                 char *arg;
 571                 if (!strcasecmp(cmd, "kgs-time_settings")) {
 572                         next_tok(time_system);
 573                 } else {
 574                         time_system = "canadian";
 575                 }
 576
 577                 int main_time = 0, byoyomi_time = 0, byoyomi_stones = 0, byoyomi_periods = 0;
 578                 if (!strcasecmp(time_system, "none")) {
 579                         main_time = -1;
 580                 } else if (!strcasecmp(time_system, "absolute")) {
 581                         next_tok(arg);
 582                         main_time = atoi(arg);
 583                 } else if (!strcasecmp(time_system, "byoyomi")) {
 584                         next_tok(arg);
 585                         main_time = atoi(arg);
 586                         next_tok(arg);
 587                         byoyomi_time = atoi(arg);
 588                         next_tok(arg);
 589                         byoyomi_periods = atoi(arg);
 590                 } else if (!strcasecmp(time_system, "canadian")) {
 591                         next_tok(arg);
 592                         main_time = atoi(arg);
 593                         next_tok(arg);
 594                         byoyomi_time = atoi(arg);
 595                         next_tok(arg);
 596                         byoyomi_stones = atoi(arg);
 597                 }
 598
 599                 if (DEBUGL(1))
 600                         fprintf(stderr, "time_settings %d %d/%d*%d\n",
 601                                 main_time, byoyomi_time, byoyomi_stones, byoyomi_periods);
 602                 if (!ti[S_BLACK].ignore_gtp) {
 603                         time_settings(&ti[S_BLACK], main_time, byoyomi_time, byoyomi_stones, byoyomi_periods);
 604                         ti[S_WHITE] = ti[S_BLACK];
 605                 } else {
 606                         if (DEBUGL(1)) fprintf(stderr, "ignored time info\n");
 607                 }
 608
 609                 gtp_reply(id, NULL);
 610
 611         } else {
 612                 gtp_error(id, "unknown command", NULL);
 613                 return P_UNKNOWN_COMMAND;
 614         }
 615         return P_OK;
 616
 617 #undef next_tok
 618 }