fbook.c

   1 #include <assert.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 #include "board.h"
   7 #include "debug.h"
   8 #include "fbook.h"
   9 #include "random.h"
  10
  11
  12 static coord_t
  13 coord_transform(struct board *b, coord_t coord, int i)
  14 {
  15 #define HASH_VMIRROR     1
  16 #define HASH_HMIRROR     2
  17 #define HASH_XYFLIP      4
  18         if (i & HASH_VMIRROR) {
  19                 coord = coord_xy(b, coord_x(coord, b), board_size(b) - 1 - coord_y(coord, b));
  20         }
  21         if (i & HASH_HMIRROR) {
  22                 coord = coord_xy(b, board_size(b) - 1 - coord_x(coord, b), coord_y(coord, b));
  23         }
  24         if (i & HASH_XYFLIP) {
  25                 coord = coord_xy(b, coord_y(coord, b), coord_x(coord, b));
  26         }
  27         return coord;
  28 }
  29
  30 /* Check if we can make a move along the fbook right away.
  31  * Otherwise return pass. */
  32 coord_t
  33 fbook_check(struct board *board)
  34 {
  35         if (!board->fbook) return pass;
  36
  37         hash_t hi = board->hash;
  38         coord_t cf = pass;
  39         while (!is_pass(board->fbook->moves[hi & fbook_hash_mask])) {
  40                 if (board->fbook->hashes[hi & fbook_hash_mask] == board->hash) {
  41                         cf = board->fbook->moves[hi & fbook_hash_mask];
  42                         break;
  43                 }
  44                 hi++;
  45         }
  46         if (!is_pass(cf)) {
  47                 if (DEBUGL(1))
  48                         fprintf(stderr, "fbook match %"PRIhash":%"PRIhash"\n", board->hash, board->hash & fbook_hash_mask);
  49         } else {
  50                 /* No match, also prevent further fbook usage
  51                  * until the next clear_board. */
  52                 if (DEBUGL(4))
  53                         fprintf(stderr, "fbook out %"PRIhash":%"PRIhash"\n", board->hash, board->hash & fbook_hash_mask);
  54                 fbook_done(board->fbook);
  55                 board->fbook = NULL;
  56         }
  57         return cf;
  58 }
  59
  60 struct fbook *
  61 fbook_init(char *filename, struct board *b)
  62 {
  63         FILE *f = fopen(filename, "r");
  64         if (!f) {
  65                 perror(filename);
  66                 return NULL;
  67         }
  68
  69         struct fbook *fbook = calloc(1, sizeof(*fbook));
  70         fbook->bsize = board_size(b);
  71         fbook->handicap = b->handicap;
  72         if (!b->handicap && b->komi < 1)
  73                 fbook->handicap = 1;
  74         for (int i = 0; i < 1<<fbook_hash_bits; i++)
  75                 fbook->moves[i] = pass;
  76
  77         if (DEBUGL(1))
  78                 fprintf(stderr, "Loading opening fbook %s...\n", filename);
  79
  80         /* Scratch board where we lay out the sequence;
  81          * one for each transposition. */
  82         struct board *bs[8];
  83         for (int i = 0; i < 8; i++) {
  84                 bs[i] = board_init(NULL);
  85                 board_resize(bs[i], fbook->bsize - 2);
  86         }
  87
  88         char linebuf[1024];
  89         while (fgets(linebuf, sizeof(linebuf), f)) {
  90                 char *line = linebuf;
  91                 linebuf[strlen(linebuf) - 1] = 0; // chop
  92
  93                 /* Format of line is:
  94                  * BSIZE COORD COORD COORD... | COORD
  95                  * BSIZE/HANDI COORD COORD COORD... | COORD
  96                  * We descend up to |, then add the new node
  97                  * with value minimax(1000), forcing UCT to
  98                  * always pick that node immediately. */
  99                 int bsize = strtol(line, &line, 10);
 100                 if (bsize != fbook->bsize - 2)
 101                         continue;
 102                 int handi = 0;
 103                 if (*line == '/') {
 104                         line++;
 105                         handi = strtol(line, &line, 10);
 106                 }
 107                 if (handi != fbook->handicap)
 108                         continue;
 109                 while (isspace(*line)) line++;
 110
 111                 for (int i = 0; i < 8; i++) {
 112                         board_clear(bs[i]);
 113                         bs[i]->last_move.color = S_WHITE;
 114                 }
 115
 116                 while (*line != '|') {
 117                         coord_t *c = str2coord(line, fbook->bsize);
 118
 119                         for (int i = 0; i < 8; i++) {
 120                                 coord_t coord = coord_transform(b, *c, i);
 121                                 struct move m = { .coord = coord, .color = stone_other(bs[i]->last_move.color) };
 122                                 int ret = board_play(bs[i], &m);
 123                                 assert(ret >= 0);
 124                         }
 125
 126                         coord_done(c);
 127                         while (!isspace(*line)) line++;
 128                         while (isspace(*line)) line++;
 129                 }
 130
 131                 line++;
 132                 while (isspace(*line)) line++;
 133
 134                 /* In case of multiple candidates, pick one with
 135                  * exponentially decreasing likelihood. */
 136                 while (strchr(line, ' ') && fast_random(2)) {
 137                         line = strchr(line, ' ');
 138                         while (isspace(*line)) line++;
 139                         // fprintf(stderr, "<%s> skip to %s\n", linebuf, line);
 140                 }
 141
 142                 coord_t *c = str2coord(line, fbook->bsize);
 143                 for (int i = 0; i < 8; i++) {
 144                         coord_t coord = coord_transform(b, *c, i);
 145 #if 0
 146                         char conflict = is_pass(fbook->moves[bs[i]->hash & fbook_hash_mask]) ? '+' : 'C';
 147                         if (conflict == 'C')
 148                                 for (int j = 0; j < i; j++)
 149                                         if (bs[i]->hash == bs[j]->hash)
 150                                                 conflict = '+';
 151                         if (conflict == 'C') {
 152                                 hash_t hi = bs[i]->hash;
 153                                 while (!is_pass(fbook->moves[hi & fbook_hash_mask]) && fbook->hashes[hi & fbook_hash_mask] != bs[i]->hash)
 154                                         hi++;
 155                                 if (fbook->hashes[hi & fbook_hash_mask] == bs[i]->hash)
 156                                         hi = 'c';
 157                         }
 158                         fprintf(stderr, "%c %"PRIhash":%"PRIhash" (<%d> %s)\n", conflict,
 159                                 bs[i]->hash & fbook_hash_mask, bs[i]->hash, i, linebuf);
 160 #endif
 161                         hash_t hi = bs[i]->hash;
 162                         while (!is_pass(fbook->moves[hi & fbook_hash_mask]) && fbook->hashes[hi & fbook_hash_mask] != bs[i]->hash)
 163                                 hi++;
 164                         fbook->moves[hi & fbook_hash_mask] = coord;
 165                         fbook->hashes[hi & fbook_hash_mask] = bs[i]->hash;
 166                 }
 167                 coord_done(c);
 168         }
 169
 170         for (int i = 0; i < 8; i++) {
 171                 board_done(bs[i]);
 172         }
 173
 174         fclose(f);
 175
 176         return fbook;
 177 }
 178
 179 void fbook_done(struct fbook *fbook)
 180 {
 181         free(fbook);
 182 }