UCT significant: Move out of descent structure, track separately
[pachi/pachi-r6144.git] / gtp.c
blob80ef1c66f8f8f2afa56ec3d289ba1598a57f37d3
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>
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"
21 #define NO_REPLY (-2)
23 /* Sleep 5 seconds after a game ends to give time to kill the program. */
24 #define GAME_OVER_SLEEP 5
26 void
27 gtp_prefix(char prefix, int id)
29 if (id == NO_REPLY) return;
30 if (id >= 0)
31 printf("%c%d ", prefix, id);
32 else
33 printf("%c ", prefix);
36 void
37 gtp_flush(void)
39 putchar('\n');
40 fflush(stdout);
43 void
44 gtp_output(char prefix, int id, va_list params)
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);
52 putchar('\n');
53 gtp_flush();
56 void
57 gtp_reply(int id, ...)
59 va_list params;
60 va_start(params, id);
61 gtp_output('=', id, params);
62 va_end(params);
65 void
66 gtp_error(int id, ...)
68 va_list params;
69 va_start(params, id);
70 gtp_output('?', id, params);
71 va_end(params);
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";
101 /* Return true if cmd is a valid gtp command. */
102 bool
103 gtp_is_valid(char *cmd)
105 if (!cmd || !*cmd) return false;
106 char *s = strcasestr(known_commands, cmd);
107 if (!s) return false;
109 int len = strlen(cmd);
110 return s[len] == '\0' || s[len] == '\n';
113 /* XXX: THIS IS TOTALLY INSECURE!!!!
114 * Even basic input checking is missing. */
116 enum parse_code
117 gtp_parse(struct board *board, struct engine *engine, struct time_info *ti, char *buf)
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"); \
127 if (strchr(buf, '#'))
128 *strchr(buf, '#') = 0;
130 char *cmd, *next = buf;
131 next_tok(cmd);
133 int id = -1;
134 if (isdigit(*cmd)) {
135 id = atoi(cmd);
136 next_tok(cmd);
139 if (!*cmd)
140 return P_OK;
142 if (!strcasecmp(cmd, "protocol_version")) {
143 gtp_reply(id, "2", NULL);
144 return P_OK;
146 } else if (!strcasecmp(cmd, "name")) {
147 /* KGS hack */
148 gtp_reply(id, "Pachi ", engine->name, NULL);
149 return P_OK;
151 } else if (!strcasecmp(cmd, "echo")) {
152 gtp_reply(id, next, NULL);
153 return P_OK;
155 } else if (!strcasecmp(cmd, "version")) {
156 gtp_reply(id, PACHI_VERSION, ": ", engine->comment, NULL);
157 return P_OK;
159 } else if (!strcasecmp(cmd, "list_commands")) {
160 gtp_reply(id, known_commands, NULL);
161 return P_OK;
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;
182 if (!strcasecmp(cmd, "quit")) {
183 gtp_reply(id, NULL);
184 exit(0);
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;
194 board_resize(board, size);
195 gtp_reply(id, NULL);
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);
208 gtp_reply(id, NULL);
209 return P_ENGINE_RESET;
211 } else if (!strcasecmp(cmd, "komi")) {
212 char *arg;
213 next_tok(arg);
214 sscanf(arg, "%f", &board->komi);
216 if (DEBUGL(1))
217 board_print(board, stderr);
218 gtp_reply(id, NULL);
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;
235 gtp_reply(id, NULL);
237 } else if (!strcasecmp(cmd, "play")) {
238 struct move m;
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;
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));
251 // This is where kgs starts the timer, not at genmove!
252 time_start_timer(&ti[stone_other(m.color)]);
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);
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);
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;
274 if (!ti[color].len.t.timer_start) {
275 /* First game move. */
276 time_start_timer(&ti[color]);
279 coord_t cf = pass;
280 if (board->fbook)
281 cf = fbook_check(board);
282 if (!is_pass(cf)) {
283 c = coord_copy(cf);
284 } else {
285 c = engine->genmove(engine, board, &ti[color], color, !strcasecmp(cmd, "kgs-genmove_cleanup"));
287 struct move m = { *c, color };
288 if (board_play(board, &m) < 0) {
289 fprintf(stderr, "Attempted to generate an illegal move: [%s, %s]\n", coord2sstr(m.coord, board), stone2str(m.color));
290 abort();
292 char *str = coord2str(*c, board);
293 if (DEBUGL(1))
294 fprintf(stderr, "playing move %s\n", str);
295 if (DEBUGL(1)) {
296 board_print_custom(board, stderr, engine->printhook);
298 gtp_reply(id, str, NULL);
299 free(str); coord_done(c);
301 /* Account for spent time. If our GTP peer keeps our clock, this will
302 * be overriden by next time_left GTP command properly. */
303 /* (XXX: Except if we pass to byoyomi and the peer doesn't, but that
304 * should be absolutely rare situation and we will just spend a little
305 * less time than we could on next few moves.) */
306 if (ti[color].period != TT_NULL && ti[color].dim == TD_WALLTIME)
307 time_sub(&ti[color], time_now() - ti[color].len.t.timer_start, true);
309 } else if (!strcasecmp(cmd, "pachi-genmoves") || !strcasecmp(cmd, "pachi-genmoves_cleanup")) {
310 char *arg;
311 next_tok(arg);
312 enum stone color = str2stone(arg);
313 void *stats;
314 int stats_size;
316 char *reply = engine->genmoves(engine, board, &ti[color], color, next,
317 !strcasecmp(cmd, "pachi-genmoves_cleanup"),
318 &stats, &stats_size);
319 if (!reply) {
320 gtp_error(id, "genmoves error", NULL);
321 return P_OK;
323 if (DEBUGL(3))
324 fprintf(stderr, "proposing moves %s\n", reply);
325 if (DEBUGL(4))
326 board_print_custom(board, stderr, engine->printhook);
327 gtp_reply(id, reply, NULL);
328 if (stats_size > 0) {
329 double start = time_now();
330 fwrite(stats, 1, stats_size, stdout);
331 fflush(stdout);
332 if (DEBUGVV(2))
333 fprintf(stderr, "sent reply %d bytes in %.4fms\n",
334 stats_size, (time_now() - start)*1000);
337 } else if (!strcasecmp(cmd, "set_free_handicap")) {
338 struct move m;
339 m.color = S_BLACK;
341 char *arg;
342 next_tok(arg);
343 do {
344 coord_t *c = str2coord(arg, board_size(board));
345 m.coord = *c; coord_done(c);
346 if (DEBUGL(1))
347 fprintf(stderr, "setting handicap %d,%d\n", coord_x(m.coord, board), coord_y(m.coord, board));
349 if (board_play(board, &m) < 0) {
350 if (DEBUGL(0))
351 fprintf(stderr, "! ILLEGAL MOVE %d,%d,%d\n", m.color, coord_x(m.coord, board), coord_y(m.coord, board));
352 gtp_error(id, "illegal move", NULL);
354 board->handicap++;
355 next_tok(arg);
356 } while (*arg);
357 if (DEBUGL(1))
358 board_print(board, stderr);
359 gtp_reply(id, NULL);
361 /* TODO: Engine should choose free handicap; however, it tends to take
362 * overly long to think it all out, and unless it's clever its
363 * handicap stones won't be of much help. ;-) */
364 } else if (!strcasecmp(cmd, "place_free_handicap")
365 || !strcasecmp(cmd, "fixed_handicap")) {
366 char *arg;
367 next_tok(arg);
368 int stones = atoi(arg);
370 gtp_prefix('=', id);
371 board_handicap(board, stones, id == NO_REPLY ? NULL : stdout);
372 if (DEBUGL(1))
373 board_print(board, stderr);
374 if (id == NO_REPLY) return P_OK;
375 putchar('\n');
376 gtp_flush();
378 } else if (!strcasecmp(cmd, "final_score")) {
379 struct move_queue q = { .moves = 0 };
380 if (engine->dead_group_list)
381 engine->dead_group_list(engine, board, &q);
382 float score = board_official_score(board, &q);
383 char str[64];
384 if (DEBUGL(1))
385 fprintf(stderr, "counted score %.1f\n", score);
386 if (score == 0) {
387 gtp_reply(id, "0", NULL);
388 } else if (score > 0) {
389 snprintf(str, 64, "W+%.1f", score);
390 gtp_reply(id, str, NULL);
391 } else {
392 snprintf(str, 64, "B+%.1f", -score);
393 gtp_reply(id, str, NULL);
396 /* XXX: This is a huge hack. */
397 } else if (!strcasecmp(cmd, "final_status_list")) {
398 if (id == NO_REPLY) return P_OK;
399 char *arg;
400 next_tok(arg);
401 struct move_queue q = { .moves = 0 };
402 if (engine->dead_group_list)
403 engine->dead_group_list(engine, board, &q);
404 /* else we return empty list - i.e. engine not supporting
405 * this assumes all stones alive at the game end. */
406 if (!strcasecmp(arg, "dead")) {
407 gtp_prefix('=', id);
408 for (unsigned int i = 0; i < q.moves; i++) {
409 foreach_in_group(board, q.move[i]) {
410 printf("%s ", coord2sstr(c, board));
411 } foreach_in_group_end;
412 putchar('\n');
414 if (!q.moves)
415 putchar('\n');
416 gtp_flush();
417 } else if (!strcasecmp(arg, "seki") || !strcasecmp(arg, "alive")) {
418 gtp_prefix('=', id);
419 bool printed_group = false;
420 foreach_point(board) { // foreach_group, effectively
421 group_t g = group_at(board, c);
422 if (!g || g != c) continue;
424 for (unsigned int i = 0; i < q.moves; i++) {
425 if (q.move[i] == g)
426 goto next_group;
428 foreach_in_group(board, g) {
429 printf("%s ", coord2sstr(c, board));
430 } foreach_in_group_end;
431 putchar('\n');
432 printed_group = true;
433 next_group:;
434 } foreach_point_end;
435 if (!printed_group)
436 putchar('\n');
437 gtp_flush();
438 } else {
439 gtp_error(id, "illegal status specifier", NULL);
442 /* Custom commands for handling UCT opening tbook */
443 } else if (!strcasecmp(cmd, "uct_gentbook")) {
444 /* Board must be initialized properly, as if for genmove;
445 * makes sense only as 'uct_gentbook b'. */
446 char *arg;
447 next_tok(arg);
448 enum stone color = str2stone(arg);
449 if (uct_gentbook(engine, board, &ti[color], color))
450 gtp_reply(id, NULL);
451 else
452 gtp_error(id, "error generating tbook", NULL);
454 } else if (!strcasecmp(cmd, "uct_dumptbook")) {
455 char *arg;
456 next_tok(arg);
457 enum stone color = str2stone(arg);
458 uct_dumptbook(engine, board, color);
459 gtp_reply(id, NULL);
461 } else if (!strcasecmp(cmd, "uct_evaluate")) {
462 char *arg;
463 next_tok(arg);
464 enum stone color = str2stone(arg);
466 gtp_prefix('=', id);
467 /* Iterate through the list of all free coordinates
468 * and call uct_evaluate() for each. uct_evaluate()
469 * will throw NAN in case of invalid moves and such. */
470 for (int i = 0; i < board->flen; i++) {
471 float val = uct_evaluate(engine, board, &ti[color], board->f[i], color);
472 if (isnan(val))
473 continue;
474 printf("%s %1.3f\n", coord2sstr(board->f[i], board), (double) val);
476 gtp_flush();
478 } else if (!strcasecmp(cmd, "pachi-result")) {
479 /* More detailed result of the last genmove. */
480 /* For UCT, the output format is: = color move playouts winrate dynkomi */
481 char *reply = NULL;
482 if (engine->result)
483 reply = engine->result(engine, board);
484 if (reply)
485 gtp_reply(id, reply, NULL);
486 else
487 gtp_error(id, "unknown pachi-result command", NULL);
489 } else if (!strcasecmp(cmd, "kgs-chat")) {
490 char *loc;
491 next_tok(loc);
492 char *src;
493 next_tok(src);
494 char *msg;
495 next_tok(msg);
496 char *reply = NULL;
497 if (engine->chat)
498 reply = engine->chat(engine, board, msg);
499 if (reply)
500 gtp_reply(id, reply, NULL);
501 else
502 gtp_error(id, "unknown kgs-chat command", NULL);
504 } else if (!strcasecmp(cmd, "time_left")) {
505 char *arg;
506 next_tok(arg);
507 enum stone color = str2stone(arg);
508 next_tok(arg);
509 int time = atoi(arg);
510 next_tok(arg);
511 int stones = atoi(arg);
512 if (!ti[color].ignore_gtp) {
513 time_left(&ti[color], time, stones);
514 } else {
515 if (DEBUGL(2)) fprintf(stderr, "ignored time info\n");
518 gtp_reply(id, NULL);
520 } else if (!strcasecmp(cmd, "time_settings") || !strcasecmp(cmd, "kgs-time_settings")) {
521 char *time_system;
522 char *arg;
523 if (!strcasecmp(cmd, "kgs-time_settings")) {
524 next_tok(time_system);
525 } else {
526 time_system = "canadian";
529 int main_time = 0, byoyomi_time = 0, byoyomi_stones = 0, byoyomi_periods = 0;
530 if (!strcasecmp(time_system, "none")) {
531 main_time = -1;
532 } else if (!strcasecmp(time_system, "absolute")) {
533 next_tok(arg);
534 main_time = atoi(arg);
535 } else if (!strcasecmp(time_system, "byoyomi")) {
536 next_tok(arg);
537 main_time = atoi(arg);
538 next_tok(arg);
539 byoyomi_time = atoi(arg);
540 next_tok(arg);
541 byoyomi_periods = atoi(arg);
542 } else if (!strcasecmp(time_system, "canadian")) {
543 next_tok(arg);
544 main_time = atoi(arg);
545 next_tok(arg);
546 byoyomi_time = atoi(arg);
547 next_tok(arg);
548 byoyomi_stones = atoi(arg);
551 if (DEBUGL(1))
552 fprintf(stderr, "time_settings %d %d/%d*%d\n",
553 main_time, byoyomi_time, byoyomi_stones, byoyomi_periods);
554 if (!ti[S_BLACK].ignore_gtp) {
555 time_settings(&ti[S_BLACK], main_time, byoyomi_time, byoyomi_stones, byoyomi_periods);
556 ti[S_WHITE] = ti[S_BLACK];
557 } else {
558 if (DEBUGL(1)) fprintf(stderr, "ignored time info\n");
561 gtp_reply(id, NULL);
563 } else {
564 gtp_error(id, "unknown command", NULL);
565 return P_UNKNOWN_COMMAND;
567 return P_OK;
569 #undef next_tok