zzgo.c

   1 #define DEBUG
   2 #include <assert.h>
   3 #include <getopt.h>
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <time.h>
   8 #include <unistd.h>
   9
  10 #include "board.h"
  11 #include "debug.h"
  12 #include "engine.h"
  13 #include "replay/replay.h"
  14 #include "montecarlo/montecarlo.h"
  15 #include "random/random.h"
  16 #include "patternscan/patternscan.h"
  17 #include "t-unit/test.h"
  18 #include "uct/uct.h"
  19 #include "gtp.h"
  20 #include "timeinfo.h"
  21 #include "random.h"
  22 #include "version.h"
  23
  24 int debug_level = 3;
  25 int seed;
  26
  27
  28 enum engine_id {
  29         E_RANDOM,
  30         E_REPLAY,
  31         E_PATTERNSCAN,
  32         E_MONTECARLO,
  33         E_UCT,
  34         E_MAX,
  35 };
  36
  37 static struct engine *(*engine_init[E_MAX])(char *arg, struct board *b) = {
  38         engine_random_init,
  39         engine_replay_init,
  40         engine_patternscan_init,
  41         engine_montecarlo_init,
  42         engine_uct_init,
  43 };
  44
  45 static struct engine *init_engine(enum engine_id engine, char *e_arg, struct board *b)
  46 {
  47         char *arg = e_arg? strdup(e_arg) : e_arg;
  48         assert(engine < E_MAX);
  49         struct engine *e = engine_init[engine](arg, b);
  50         if (arg) free(arg);
  51         return e;
  52 }
  53
  54 static void done_engine(struct engine *e)
  55 {
  56         if (e->done) e->done(e);
  57         if (e->data) free(e->data);
  58         free(e);
  59 }
  60
  61 bool engine_reset = false;
  62
  63
  64 int main(int argc, char *argv[])
  65 {
  66         enum engine_id engine = E_UCT;
  67         struct time_info ti_default = { .period = TT_NULL };
  68         char *testfile = NULL;
  69
  70         seed = time(NULL) ^ getpid();
  71
  72         int opt;
  73         while ((opt = getopt(argc, argv, "e:d:s:t:u:")) != -1) {
  74                 switch (opt) {
  75                         case 'e':
  76                                 if (!strcasecmp(optarg, "random")) {
  77                                         engine = E_RANDOM;
  78                                 } else if (!strcasecmp(optarg, "patternscan")) {
  79                                         engine = E_PATTERNSCAN;
  80                                 } else if (!strcasecmp(optarg, "replay")) {
  81                                         engine = E_REPLAY;
  82                                 } else if (!strcasecmp(optarg, "montecarlo")) {
  83                                         engine = E_MONTECARLO;
  84                                 } else if (!strcasecmp(optarg, "uct")) {
  85                                         engine = E_UCT;
  86                                 } else {
  87                                         fprintf(stderr, "%s: Invalid -e argument %s\n", argv[0], optarg);
  88                                         exit(1);
  89                                 }
  90                                 break;
  91                         case 'd':
  92                                 debug_level = atoi(optarg);
  93                                 break;
  94                         case 's':
  95                                 seed = atoi(optarg);
  96                                 break;
  97                         case 't':
  98                                 /* Time settings to follow; if specified,
  99                                  * GTP time information is ignored. Useful
 100                                  * e.g. when you want to force your bot to
 101                                  * play weaker while giving the opponent
 102                                  * reasonable time to play, or force play
 103                                  * by number of simulations in timed games. */
 104                                 /* Please see timeinfo.h:time_parse()
 105                                  * description for syntax details. */
 106                                 if (!time_parse(&ti_default, optarg)) {
 107                                         fprintf(stderr, "%s: Invalid -t argument %s\n", argv[0], optarg);
 108                                         exit(1);
 109                                 }
 110                                 ti_default.ignore_gtp = true;
 111                                 /* Check for unsupported combinations. */
 112                                 assert(ti_default.period != TT_NULL);
 113                                 if (ti_default.dim == TD_GAMES && ti_default.period == TT_TOTAL) {
 114                                         fprintf(stderr, "%s: Spreading fixed simulations# over the whole game is not supported\n", argv[0]);
 115                                         exit(1);
 116                                 }
 117                                 if (ti_default.dim == TD_WALLTIME && ti_default.period == TT_TOTAL) {
 118                                         fprintf(stderr, "%s: Spreading fixed time over the whole game without GTP time_left aid is not supported for now\n", argv[0]);
 119                                         exit(1);
 120                                 }
 121                                 break;
 122                         case 'u':
 123                                 testfile = strdup(optarg);
 124                                 break;
 125                         default: /* '?' */
 126                                 fprintf(stderr, "Pachi version %s\n", PACHI_VERSION);
 127                                 fprintf(stderr, "Usage: %s [-e random|replay|patternscan|montecarlo|uct] [-d DEBUG_LEVEL] [-s RANDOM_SEED] [-t TIME_SETTINGS] [-u TEST_FILENAME] [ENGINE_ARGS]\n",
 128                                                 argv[0]);
 129                                 exit(1);
 130                 }
 131         }
 132
 133         fast_srandom(seed);
 134         fprintf(stderr, "Random seed: %d\n", seed);
 135
 136         struct board *b = board_init();
 137         struct time_info ti[S_MAX];
 138         ti[S_BLACK] = ti_default;
 139         ti[S_WHITE] = ti_default;
 140
 141         char *e_arg = NULL;
 142         if (optind < argc)
 143                 e_arg = argv[optind];
 144         struct engine *e = init_engine(engine, e_arg, b);
 145
 146         if (testfile) {
 147                 unittest(testfile);
 148                 return 0;
 149         }
 150
 151         char buf[4096];
 152         while (fgets(buf, 4096, stdin)) {
 153                 if (DEBUGL(1))
 154                         fprintf(stderr, "IN: %s", buf);
 155                 gtp_parse(b, e, ti, buf);
 156                 if (engine_reset) {
 157                         if (!e->keep_on_clear) {
 158                                 b->es = NULL;
 159                                 done_engine(e);
 160                                 e = init_engine(engine, e_arg, b);
 161                                 ti[S_BLACK] = ti_default;
 162                                 ti[S_WHITE] = ti_default;
 163                         }
 164                         engine_reset = false;
 165                 }
 166         }
 167         done_engine(e);
 168         return 0;
 169 }