Distributed engine code cleanup: split select_best_move() in two functions.
[pachi/pachi-r6144.git] / gtp.c
bloba3c59bc167f649a43eac0c2fde7cb4830d01d405
1 #define DEBUG
2 #include <assert.h>
3 #include <ctype.h>
4 #include <stdarg.h>
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <string.h>
8 #include <unistd.h>
10 #include "board.h"
11 #include "debug.h"
12 #include "engine.h"
13 #include "gtp.h"
14 #include "mq.h"
15 #include "uct/uct.h"
16 #include "version.h"
17 #include "timeinfo.h"
19 #define NO_REPLY (-2)
21 /* Sleep 5 seconds after a game ends to give time to kill the program. */
22 #define GAME_OVER_SLEEP 5
24 void
25 gtp_prefix(char prefix, int id)
27 if (id == NO_REPLY) return;
28 if (id >= 0)
29 printf("%c%d ", prefix, id);
30 else
31 printf("%c ", prefix);
34 void
35 gtp_flush(void)
37 putchar('\n');
38 fflush(stdout);
41 void
42 gtp_output(char prefix, int id, va_list params)
44 if (id == NO_REPLY) return;
45 gtp_prefix(prefix, id);
46 char *s;
47 while ((s = va_arg(params, char *))) {
48 fputs(s, stdout);
50 putchar('\n');
51 gtp_flush();
54 void
55 gtp_reply(int id, ...)
57 va_list params;
58 va_start(params, id);
59 gtp_output('=', id, params);
60 va_end(params);
63 void
64 gtp_error(int id, ...)
66 va_list params;
67 va_start(params, id);
68 gtp_output('?', id, params);
69 va_end(params);
73 /* XXX: THIS IS TOTALLY INSECURE!!!!
74 * Even basic input checking is missing. */
76 enum parse_code
77 gtp_parse(struct board *board, struct engine *engine, struct time_info *ti, char *buf)
79 #define next_tok(to_) \
80 to_ = next; \
81 next = next + strcspn(next, " \t\r\n"); \
82 if (*next) { \
83 *next = 0; next++; \
84 next += strspn(next, " \t\r\n"); \
87 if (strchr(buf, '#'))
88 *strchr(buf, '#') = 0;
90 char *cmd, *next = buf;
91 next_tok(cmd);
93 int id = -1;
94 if (isdigit(*cmd)) {
95 id = atoi(cmd);
96 next_tok(cmd);
99 if (!*cmd)
100 return P_OK;
102 if (!strcasecmp(cmd, "protocol_version")) {
103 gtp_reply(id, "2", NULL);
104 return P_OK;
106 } else if (!strcasecmp(cmd, "name")) {
107 /* KGS hack */
108 gtp_reply(id, "Pachi ", engine->name, NULL);
109 return P_OK;
111 } else if (!strcasecmp(cmd, "version")) {
112 gtp_reply(id, PACHI_VERSION, ": ", engine->comment, NULL);
113 return P_OK;
115 /* TODO: known_command */
117 } else if (!strcasecmp(cmd, "list_commands")) {
118 /* The internal command pachi-genmoves is not exported,
119 * it should only be used between master and slaves of
120 * the distributed engine. */
121 gtp_reply(id, "protocol_version\n"
122 "name\n"
123 "version\n"
124 "list_commands\n"
125 "quit\n"
126 "boardsize\n"
127 "clear_board\n"
128 "kgs-game_over\n"
129 "komi\n"
130 "kgs-rules\n"
131 "play\n"
132 "genmove\n"
133 "kgs-genmove_cleanup\n"
134 "set_free_handicap\n"
135 "place_free_handicap\n"
136 "final_status_list\n"
137 "kgs-chat\n"
138 "time_left\n"
139 "time_settings\n"
140 "kgs-time_settings", NULL);
141 return P_OK;
144 if (engine->notify) {
145 char *reply;
146 enum parse_code c = engine->notify(engine, board, id, cmd, next, &reply);
147 if (c == P_NOREPLY) {
148 id = NO_REPLY;
149 } else if (c == P_DONE_OK) {
150 gtp_reply(id, reply, NULL);
151 return P_OK;
152 } else if (c == P_DONE_ERROR) {
153 gtp_error(id, reply, NULL);
154 /* This is an internal error for the engine, but
155 * it is still OK from main's point of view. */
156 return P_OK;
157 } else if (c != P_OK) {
158 return c;
162 if (!strcasecmp(cmd, "quit")) {
163 gtp_reply(id, NULL);
164 exit(0);
166 } else if (!strcasecmp(cmd, "boardsize")) {
167 char *arg;
168 next_tok(arg);
169 board_resize(board, atoi(arg));
171 gtp_reply(id, NULL);
173 } else if (!strcasecmp(cmd, "clear_board") || !strcasecmp(cmd, "kgs-game_over")) {
174 board_clear(board);
175 if (DEBUGL(1))
176 board_print(board, stderr);
177 if (!strcasecmp(cmd, "kgs-game_over")) {
178 if (DEBUGL(0))
179 fprintf(stderr, "game is over\n");
180 /* Sleep before replying, so that kgs doesn't
181 * start another game immediately. */
182 sleep(GAME_OVER_SLEEP);
184 gtp_reply(id, NULL);
185 return P_ENGINE_RESET;
187 } else if (!strcasecmp(cmd, "komi")) {
188 char *arg;
189 next_tok(arg);
190 sscanf(arg, "%f", &board->komi);
192 if (DEBUGL(1))
193 board_print(board, stderr);
194 gtp_reply(id, NULL);
196 } else if (!strcasecmp(cmd, "kgs-rules")) {
197 char *arg;
198 next_tok(arg);
199 if (!strcasecmp(arg, "japanese")) {
200 board->rules = RULES_JAPANESE;
201 } else if (!strcasecmp(arg, "chinese")) {
202 board->rules = RULES_CHINESE;
203 } else if (!strcasecmp(arg, "aga")) {
204 board->rules = RULES_AGA;
205 } else if (!strcasecmp(arg, "new_zealand")) {
206 board->rules = RULES_NEW_ZEALAND;
207 } else {
208 gtp_error(id, "unknown rules", NULL);
209 return P_OK;
211 gtp_reply(id, NULL);
213 } else if (!strcasecmp(cmd, "play")) {
214 struct move m;
216 char *arg;
217 next_tok(arg);
218 m.color = str2stone(arg);
219 next_tok(arg);
220 coord_t *c = str2coord(arg, board_size(board));
221 m.coord = *c; coord_done(c);
222 char *reply = NULL;
224 if (DEBUGL(1))
225 fprintf(stderr, "got move %d,%d,%d\n", m.color, coord_x(m.coord, board), coord_y(m.coord, board));
227 // This is where kgs starts the timer, not at genmove!
228 time_start_timer(&ti[stone_other(m.color)]);
230 if (engine->notify_play)
231 reply = engine->notify_play(engine, board, &m);
232 if (board_play(board, &m) < 0) {
233 if (DEBUGL(0)) {
234 fprintf(stderr, "! ILLEGAL MOVE %d,%d,%d\n", m.color, coord_x(m.coord, board), coord_y(m.coord, board));
235 board_print(board, stderr);
237 gtp_error(id, "illegal move", NULL);
238 } else {
239 if (DEBUGL(1))
240 board_print(board, stderr);
241 gtp_reply(id, reply, NULL);
244 } else if (!strcasecmp(cmd, "genmove") || !strcasecmp(cmd, "kgs-genmove_cleanup")) {
245 char *arg;
246 next_tok(arg);
247 enum stone color = str2stone(arg);
249 coord_t *c = engine->genmove(engine, board, &ti[color], color, !strcasecmp(cmd, "kgs-genmove_cleanup"));
250 struct move m = { *c, color };
251 board_play(board, &m);
252 char *str = coord2str(*c, board);
253 if (DEBUGL(1))
254 fprintf(stderr, "playing move %s\n", str);
255 if (DEBUGL(1)) {
256 board_print_custom(board, stderr, engine->printhook);
258 gtp_reply(id, str, NULL);
259 free(str); coord_done(c);
261 /* Account for spent time. If our GTP peer keeps our clock, this will
262 * be overriden by next time_left GTP command properly. */
263 /* (XXX: Except if we pass to byoyomi and the peer doesn't, but that
264 * should be absolutely rare situation and we will just spend a little
265 * less time than we could on next few moves.) */
266 if (ti[color].period != TT_NULL && ti[color].dim == TD_WALLTIME)
267 time_sub(&ti[color], time_now() - ti[color].len.t.timer_start);
269 } else if (!strcasecmp(cmd, "pachi-genmoves") || !strcasecmp(cmd, "pachi-genmoves_cleanup")) {
270 char *arg;
271 next_tok(arg);
272 enum stone color = str2stone(arg);
274 char *reply = engine->genmoves(engine, board, &ti[color], color, next,
275 !strcasecmp(cmd, "pachi-genmoves_cleanup"));
276 if (!reply) {
277 gtp_error(id, "genmoves error", NULL);
278 return P_OK;
280 if (DEBUGL(2))
281 fprintf(stderr, "proposing moves %s\n", reply);
282 if (DEBUGL(1)) {
283 board_print_custom(board, stderr, engine->printhook);
285 gtp_reply(id, reply, NULL);
287 } else if (!strcasecmp(cmd, "set_free_handicap")) {
288 struct move m;
289 m.color = S_BLACK;
291 char *arg;
292 next_tok(arg);
293 do {
294 coord_t *c = str2coord(arg, board_size(board));
295 m.coord = *c; coord_done(c);
296 if (DEBUGL(1))
297 fprintf(stderr, "setting handicap %d,%d\n", coord_x(m.coord, board), coord_y(m.coord, board));
299 if (board_play(board, &m) < 0) {
300 if (DEBUGL(0))
301 fprintf(stderr, "! ILLEGAL MOVE %d,%d,%d\n", m.color, coord_x(m.coord, board), coord_y(m.coord, board));
302 gtp_error(id, "illegal move", NULL);
304 board->handicap++;
305 next_tok(arg);
306 } while (*arg);
307 if (DEBUGL(1))
308 board_print(board, stderr);
309 gtp_reply(id, NULL);
311 /* TODO: Engine should choose free handicap; however, it tends to take
312 * overly long to think it all out, and unless it's clever its
313 * handicap stones won't be of much help. ;-) */
314 } else if (!strcasecmp(cmd, "place_free_handicap")
315 || !strcasecmp(cmd, "fixed_handicap")) {
316 char *arg;
317 next_tok(arg);
318 int stones = atoi(arg);
320 gtp_prefix('=', id);
321 board_handicap(board, stones, id == NO_REPLY ? NULL : stdout);
322 if (DEBUGL(1))
323 board_print(board, stderr);
324 if (id == NO_REPLY) return P_OK;
325 putchar('\n');
326 gtp_flush();
328 } else if (!strcasecmp(cmd, "final_score")) {
329 struct move_queue q = { .moves = 0 };
330 if (engine->dead_group_list)
331 engine->dead_group_list(engine, board, &q);
332 float score = board_official_score(board, &q);
333 char str[64];
334 if (DEBUGL(1))
335 fprintf(stderr, "counted score %.1f\n", score);
336 if (score == 0) {
337 gtp_reply(id, "0", NULL);
338 } else if (score > 0) {
339 snprintf(str, 64, "W+%.1f", score);
340 gtp_reply(id, str, NULL);
341 } else {
342 snprintf(str, 64, "B+%.1f", -score);
343 gtp_reply(id, str, NULL);
346 /* XXX: This is a huge hack. */
347 } else if (!strcasecmp(cmd, "final_status_list")) {
348 if (id == NO_REPLY) return P_OK;
349 char *arg;
350 next_tok(arg);
351 struct move_queue q = { .moves = 0 };
352 if (engine->dead_group_list)
353 engine->dead_group_list(engine, board, &q);
354 /* else we return empty list - i.e. engine not supporting
355 * this assumes all stones alive at the game end. */
356 if (!strcasecmp(arg, "dead")) {
357 gtp_prefix('=', id);
358 for (int i = 0; i < q.moves; i++) {
359 foreach_in_group(board, q.move[i]) {
360 printf("%s ", coord2sstr(c, board));
361 } foreach_in_group_end;
362 putchar('\n');
364 if (!q.moves)
365 putchar('\n');
366 gtp_flush();
367 } else if (!strcasecmp(arg, "seki") || !strcasecmp(arg, "alive")) {
368 gtp_prefix('=', id);
369 bool printed_group = false;
370 foreach_point(board) { // foreach_group, effectively
371 group_t g = group_at(board, c);
372 if (!g || g != c) continue;
374 for (int i = 0; i < q.moves; i++) {
375 if (q.move[i] == g)
376 goto next_group;
378 foreach_in_group(board, g) {
379 printf("%s ", coord2sstr(c, board));
380 } foreach_in_group_end;
381 putchar('\n');
382 printed_group = true;
383 next_group:;
384 } foreach_point_end;
385 if (!printed_group)
386 putchar('\n');
387 gtp_flush();
388 } else {
389 gtp_error(id, "illegal status specifier", NULL);
392 /* Custom commands for handling UCT opening book */
393 } else if (!strcasecmp(cmd, "uct_genbook")) {
394 /* Board must be initialized properly, as if for genmove;
395 * makes sense only as 'uct_genbook b'. */
396 char *arg;
397 next_tok(arg);
398 enum stone color = str2stone(arg);
399 if (uct_genbook(engine, board, &ti[color], color))
400 gtp_reply(id, NULL);
401 else
402 gtp_error(id, "error generating book", NULL);
404 } else if (!strcasecmp(cmd, "uct_dumpbook")) {
405 char *arg;
406 next_tok(arg);
407 enum stone color = str2stone(arg);
408 uct_dumpbook(engine, board, color);
409 gtp_reply(id, NULL);
411 } else if (!strcasecmp(cmd, "kgs-chat")) {
412 char *loc;
413 next_tok(loc);
414 char *src;
415 next_tok(src);
416 char *msg;
417 next_tok(msg);
418 char *reply = NULL;
419 if (engine->chat)
420 reply = engine->chat(engine, board, msg);
421 if (reply)
422 gtp_reply(id, reply, NULL);
423 else
424 gtp_error(id, "unknown chat command", NULL);
426 } else if (!strcasecmp(cmd, "time_left")) {
427 char *arg;
428 next_tok(arg);
429 enum stone color = str2stone(arg);
430 next_tok(arg);
431 int time = atoi(arg);
432 next_tok(arg);
433 int stones = atoi(arg);
434 if (!ti[color].ignore_gtp) {
435 time_left(&ti[color], time, stones);
436 } else {
437 if (DEBUGL(2)) fprintf(stderr, "ignored time info\n");
440 gtp_reply(id, NULL);
442 } else if (!strcasecmp(cmd, "time_settings") || !strcasecmp(cmd, "kgs-time_settings")) {
443 char *time_system;
444 char *arg;
445 if (!strcasecmp(cmd, "kgs-time_settings")) {
446 next_tok(time_system);
447 } else {
448 time_system = "canadian";
451 int main_time = 0, byoyomi_time = 0, byoyomi_stones = 0, byoyomi_periods = 0;
452 if (!strcasecmp(time_system, "none")) {
453 main_time = -1;
454 } else if (!strcasecmp(time_system, "absolute")) {
455 next_tok(arg);
456 main_time = atoi(arg);
457 } else if (!strcasecmp(time_system, "byoyomi")) {
458 next_tok(arg);
459 main_time = atoi(arg);
460 next_tok(arg);
461 byoyomi_time = atoi(arg);
462 next_tok(arg);
463 byoyomi_periods = atoi(arg);
464 } else if (!strcasecmp(time_system, "canadian")) {
465 next_tok(arg);
466 main_time = atoi(arg);
467 next_tok(arg);
468 byoyomi_time = atoi(arg);
469 next_tok(arg);
470 byoyomi_stones = atoi(arg);
473 if (DEBUGL(1))
474 fprintf(stderr, "time_settings %d %d/%d*%d\n",
475 main_time, byoyomi_time, byoyomi_stones, byoyomi_periods);
476 if (!ti[S_BLACK].ignore_gtp) {
477 time_settings(&ti[S_BLACK], main_time, byoyomi_time, byoyomi_stones, byoyomi_periods);
478 ti[S_WHITE] = ti[S_BLACK];
479 } else {
480 if (DEBUGL(1)) fprintf(stderr, "ignored time info\n");
483 gtp_reply(id, NULL);
485 } else {
486 gtp_error(id, "unknown command", NULL);
487 return P_UNKNOWN_COMMAND;
489 return P_OK;
491 #undef next_tok