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