Ticket #25: arend_7_7.10-remove_interface_wrappers.diff

engine/gnugo.h

@@ -85 +85 @@
 
 
 void gnugo_clear_board(int boardsize);
-void gnugo_set_komi(float new_komi);
-void gnugo_add_stone(int i, int j, int color);
-void gnugo_remove_stone(int i, int j);
-int  gnugo_is_pass(int i, int j);
 void gnugo_play_move(int i, int j, int color);
-int  gnugo_undo_move(int n);
 int  gnugo_play_sgfnode(SGFNode *node, int to_move);
 int  gnugo_play_sgftree(SGFNode *root, int *until, SGFNode **curnode);
-int  gnugo_is_legal(int i, int j, int color);
-int  gnugo_is_suicide(int i, int j, int color);
 
-int  gnugo_placehand(int handicap);
 int  gnugo_sethand(int handicap, SGFNode *root);
-void gnugo_recordboard(SGFNode *node);
 
 float gnugo_genmove(int *i, int *j, int color, int *resign);
 
 int  gnugo_attack(int m, int n, int *i, int *j);
 int  gnugo_find_defense(int m, int n, int *i, int *j);
 
-void  gnugo_who_wins(int color, FILE *outfile);
 float gnugo_estimate_score(float *upper, float *lower);
-
-float gnugo_get_komi(void);
-void  gnugo_get_board(int b[MAX_BOARD][MAX_BOARD]);
-int   gnugo_get_boardsize(void);
-int   gnugo_get_move_number(void);
 
 /* ================================================================ */
 /*                           Game handling                          */

engine/interface.c

@@ -74 +74 @@
 #endif
 }
 
-/* Set the komi */
-
-void
-gnugo_set_komi(float new_komi)
-{
-  komi = new_komi;
-}
-
-/* Place a stone on the board */
-
-void
-gnugo_add_stone(int i, int j, int color)
-{
-  add_stone(POS(i, j), color);
-}
-
-/* Remove a stone from the board */
-
-void
-gnugo_remove_stone(int i, int j)
-{
-  remove_stone(POS(i, j));
-}
-
-/* Return true if (i,j) is PASS_MOVE */
-
-int
-gnugo_is_pass(int i, int j)
-{
-  return is_pass(POS(i, j));
-}
-
 /* Play a move and start the clock */
 
 void
@@ -122 +90 @@
   clock_push_button(color);
 }
 
-/* Undo n permanent moves. Returns 1 if successful and 0 if it fails.
- * If n moves cannot be undone, no move is undone.
- */
-
-int
-gnugo_undo_move(int n)
-{
-  return undo_move(n);
-}
-
 
 /*
  * Perform the moves and place the stones from the SGF node on the 
@@ -149 +107 @@
     case SGFAB:
       /* A black stone. */
       get_moveXY(prop, &i, &j, board_size);
-      gnugo_add_stone(i, j, BLACK);
+      add_stone(POS(i, j), BLACK);
       break;
 
     case SGFAW:
       /* A white stone. */
       get_moveXY(prop, &i, &j, board_size);
-      gnugo_add_stone(i, j, WHITE);
+      add_stone(POS(i, j), WHITE);
       break;
 
     case SGFPL:
@@ -202 +160 @@
       switch (prop->name) {
       case SGFAB:
         get_moveXY(prop, &i, &j, board_size);
-        gnugo_add_stone(i, j, BLACK);
+        add_stone(POS(i, j), BLACK);
         break;
 
       case SGFAW:
         get_moveXY(prop, &i, &j, board_size);
-        gnugo_add_stone(i, j, WHITE);
+        add_stone(POS(i, j), WHITE);
         break;
 
       case SGFPL:
@@ -238 +196 @@
 }
 
 
-/* Interface to is_legal(). */
-int
-gnugo_is_legal(int i, int j, int color)
-{
-  return is_legal(POS(i, j), color);
-}
-
-
-/* Interface to is_suicide(). */
-int
-gnugo_is_suicide(int i, int j, int color)
-{
-  return is_suicide(POS(i, j), color);
-}
-
-
-/* Interface to placehand. Sets up handicap stones and
- * returns the number of placed handicap stones. */
-int
-gnugo_placehand(int handicap)
-{
-  return place_fixed_handicap(handicap);
-}
-
-
-/* Interface to sgffile_recordboard */
-void
-gnugo_recordboard(SGFNode *root)
-{
-  sgffile_recordboard(root);
-}
-
 /* Interface to placehand. Sets up handicap stones and
  * returns the number of placed handicap stones, updating the sgf file.
  */
@@ -332 +258 @@
 }
 
 
-/* Interface to who_wins */
-void
-gnugo_who_wins(int color, FILE *outfile)
-{
-  who_wins(color, outfile);
-}
-
-
 /* Put upper and lower score estimates into *upper, *lower and
  * return the average. A positive score favors white. In computing
  * the upper bound, CRITICAL dragons are awarded to white; in
@@ -358 +276 @@
 }
 
 
-/* Accessor functions for internal board state. */
-
-/* Report the komi. */
-
-float
-gnugo_get_komi()
-{
-  return komi;
-}
-
-/* Place the board into the b array */
-
-void
-gnugo_get_board(int b[MAX_BOARD][MAX_BOARD])
-{
-  int i, j;
-  for (i = 0; i < board_size; i++)
-    for (j = 0; j < board_size; j++)
-      b[i][j] = BOARD(i, j);
-}
-
-int
-gnugo_get_boardsize()
-{
-  return board_size;
-}
-
-int
-gnugo_get_move_number()
-{
-  return movenum;
-}
-
 /* ================================================================ */
 /*                             Gameinfo                             */
 /* ================================================================ */
@@ -401 +286 @@
  */
 
 void
-gameinfo_clear(Gameinfo *ginfo, int boardsize, float komi)
+gameinfo_clear(Gameinfo *ginfo, int boardsize, float new_komi)
 {
   ginfo->handicap = 0;
   
   gnugo_clear_board(boardsize);
-  gnugo_set_komi(komi);
+  komi = new_komi;
   ginfo->to_move = BLACK;
   sgftree_clear(&ginfo->game_record);
 
@@ -450 +335 @@
 {
   int bsize;
   int handicap;
-  float komi;
   
   if (!sgfGetIntProperty(head, "SZ", &bsize))
     bsize = 19;
@@ -458 +342 @@
     komi = 5.5;
   
   gnugo_clear_board(bsize);
-  gnugo_set_komi(komi);
   
   if (!sgfGetIntProperty(head, "HA", &handicap) || handicap < 0)
     /* Handicap stones should appear as AW, AB properties in the sgf file. */
@@ -505 +388 @@
                           const char *untilstr, int orientation)
 {
   int bs, handicap;
-  float komi;
   int next = BLACK;
   
   int untilm = -1, untiln = -1;
@@ -520 +402 @@
   if (!sgfGetIntProperty(tree->root, "SZ", &bs))
     bs = 19;
   gnugo_clear_board(bs);
-  gnugo_set_komi(komi);
 
   /* Now we can safely parse the until string (which depends on board size). */
   if (untilstr) {
@@ -575 +456 @@
           gprintf("Illegal SGF! attempt to add a stone at occupied point %m\n",
                   i, j);
         else
-          gnugo_add_stone(i, j, BLACK);
+          add_stone(POS(i, j), BLACK);
         break;
               
       case SGFAW:
@@ -585 +466 @@
           gprintf("Illegal SGF! attempt to add a stone at occupied point %m\n",
                   i, j);
         else
-          gnugo_add_stone(i, j, WHITE);
+          add_stone(POS(i, j), WHITE);
         break;
               
       case SGFPL:

interface/play_ascii.c

@@ -444 +444 @@
                    level, chinese_rules);
   sgfOverwritePropertyInt(sgftree.root, "HA", ginfo->handicap);
   if (ginfo->handicap > 0)
-    gnugo_recordboard(sgftree.root);
+    sgffile_recordboard(sgftree.root);
 }
 
 
@@ -513 +513 @@
     return 0;
   }
   
-  if (!gnugo_is_legal(i, j, gameinfo->to_move)) {
+  if (!is_legal(POS(i, j), gameinfo->to_move)) {
     printf("\nIllegal move: %s", command);
     return 0;
   }
@@ -592 +592 @@
     if (gameinfo->handicap == 0)
       gameinfo->to_move = BLACK;
     else {
-      gameinfo->handicap = gnugo_placehand(gameinfo->handicap);
+      gameinfo->handicap = place_fixed_handicap(gameinfo->handicap);
       gameinfo->to_move = WHITE;
     }
     sgf_initialized = 0;
@@ -709 +709 @@
           /* Init board. */
           gnugo_clear_board(sz);
           /* In case max handicap changes on smaller board. */
-          gameinfo->handicap = gnugo_placehand(gameinfo->handicap);
+          gameinfo->handicap = place_fixed_handicap(gameinfo->handicap);
           sgfOverwritePropertyInt(sgftree.root, "SZ", sz);
           sgfOverwritePropertyInt(sgftree.root, "HA", gameinfo->handicap);
           break;
@@ -732 +732 @@
           gnugo_clear_board(board_size);
           /* Place stones on board but don't record sgf 
            * in case we change more info. */
-          gameinfo->handicap = gnugo_placehand(num);
+          gameinfo->handicap = place_fixed_handicap(num);
           printf("\nSet handicap to %d\n", gameinfo->handicap);
           gameinfo->to_move = (gameinfo->handicap ? WHITE : BLACK);
           break;
@@ -866 +866 @@
 
         case UNDO:
         case CMD_BACK:
-          if (gnugo_undo_move(1)) {
+          if (undo_move(1)) {
             sgftreeAddComment(&sgftree, "undone");
             sgftreeBack(&sgftree);
             gameinfo->to_move = OTHER_COLOR(gameinfo->to_move);
@@ -1031 +1031 @@
   int state = 0;
 
   if (reason == 0) {            /* Two passes, game is over. */
-    gnugo_who_wins(gameinfo->computer_player, stdout);
+    who_wins(gameinfo->computer_player, stdout);
     printf("\nIf you disagree, we may count the game together.\n");
 
     sgftreeWriteResult(&sgftree, (white_score + black_score)/2.0, 1);
@@ -1166 +1166 @@
       }
     }
   }
-  gnugo_who_wins(gameinfo->computer_player, stdout);
+  who_wins(gameinfo->computer_player, stdout);
 }
 
 

interface/play_gmp.c

@@ -57 +57 @@
     mycolor = 0;
 
   sgftree_clear(&sgftree);
-  sgftreeCreateHeaderNode(&sgftree, gnugo_get_boardsize(), gnugo_get_komi());
+  sgftreeCreateHeaderNode(&sgftree, board_size, komi);
 
   ge = gmp_create(0, 1);
-  TRACE("board size=%d\n", gnugo_get_boardsize());
+  TRACE("board size=%d\n", board_size);
 
   /* 
    * The specification of the go modem protocol doesn't even discuss
@@ -68 +68 @@
    * command line, keep it. Otherwise, its value will be 0.0 and we
    * use 5.5 in an even game, 0.5 otherwise.
    */
-  if (gnugo_get_komi() == 0.0) {
+  if (komi == 0.0) {
     if (gameinfo->handicap == 0)
-      gnugo_set_komi(5.5);
+      komi = 5.5;
     else
-      gnugo_set_komi(0.5);
+      komi = 0.5;
   }
 
   if (!simplified) {
@@ -84 +84 @@
   }
   else {
     gmp_startGame(ge, board_size, gameinfo->handicap,
-                  gnugo_get_komi(), chinese_rules, mycolor, 1);
+                  komi, chinese_rules, mycolor, 1);
   }
 
   do {
@@ -105 +105 @@
   gnugo_clear_board(gmp_size(ge));
 
   /* Let's pretend GMP knows about komi in case something will ever change. */
-  gnugo_set_komi(gmp_komi(ge));
+  komi = gmp_komi(ge);
 
 #if ORACLE
   if (metamachine && oracle_exists)
     oracle_clear_board(gnugo_get_boardsize());
 #endif
 
-  sgfOverwritePropertyInt(sgftree.root, "SZ", gnugo_get_boardsize());
+  sgfOverwritePropertyInt(sgftree.root, "SZ", board_size);
 
-  TRACE("size=%d, handicap=%d, komi=%f\n", gnugo_get_boardsize(),
-        gameinfo->handicap, gnugo_get_komi());
+  TRACE("size=%d, handicap=%d, komi=%f\n", board_size,
+        gameinfo->handicap, komi);
 
   if (gameinfo->handicap)
     to_move = WHITE;
@@ -132 +132 @@
   }
 
   gameinfo->computer_player = mycolor;
-  sgf_write_header(sgftree.root, 1, get_random_seed(), gnugo_get_komi(),
+  sgf_write_header(sgftree.root, 1, get_random_seed(), komi,
                    level, chinese_rules);
   gameinfo->handicap = gnugo_sethand(gameinfo->handicap, sgftree.root);
   sgfOverwritePropertyInt(sgftree.root, "HA", gameinfo->handicap);
@@ -156 +156 @@
         assert(j > 0);
         
         for (k = 0; k < j; k++) {
-          if (!gnugo_undo_move(1)) {
+          if (!undo_move(1)) {
             fprintf(stderr, "GNU Go: play_gmp UNDO: can't undo %d moves\n",
                     j - k);
             break;
@@ -190 +190 @@
       gnugo_play_move(i, j, mycolor);
       sgffile_add_debuginfo(sgftree.lastnode, move_value);
       
-      if (gnugo_is_pass(i, j)) {
+      if (is_pass(POS(i, j))) {
         /* pass */
         sgftreeAddPlay(&sgftree, to_move, -1, -1);
         gmp_sendPass(ge);

interface/play_solo.c

@@ -43 +43 @@
   float move_value;
   double t1, t2;
   int save_moves = moves;
-  int boardsize = gnugo_get_boardsize();
 
   struct stats_data totalstats;
   int total_owl_count = 0;
@@ -57 +56 @@
   int n = 6 + 2*gg_rand()%5;
   int i, j;
 
-  gnugo_set_komi(5.5);
+  komi = 5.5;
 
   sgftree_clear(&sgftree);
-  sgftreeCreateHeaderNode(&sgftree, gnugo_get_boardsize(), gnugo_get_komi());
+  sgftreeCreateHeaderNode(&sgftree, board_size, komi);
   sgf_write_header(sgftree.root, 1, get_random_seed(), 5.5,
                    level, chinese_rules);
  
   /* Generate some random moves. */
-  if (boardsize > 6) {
+  if (board_size > 6) {
     do {
       do {
-        i = (gg_rand() % 4) + (gg_rand() % (boardsize - 4));
-        j = (gg_rand() % 4) + (gg_rand() % (boardsize - 4));
-      } while (!gnugo_is_legal(i, j, gameinfo->to_move));
+        i = (gg_rand() % 4) + (gg_rand() % (board_size - 4));
+        j = (gg_rand() % 4) + (gg_rand() % (board_size - 4));
+      } while (!is_legal(POS(i, j), gameinfo->to_move));
 
       gnugo_play_move(i, j, gameinfo->to_move);
       sgftreeAddPlay(&sgftree, gameinfo->to_move, i, j);
@@ -111 +110 @@
   t2 = gg_cputime();
   
   /* Two passes and it's over. (EMPTY == BOTH) */
-  gnugo_who_wins(EMPTY, stdout);
+  who_wins(EMPTY, stdout);
 
   {
     float score = gnugo_estimate_score(NULL, NULL);

interface/play_test.c

@@ -124 +124 @@
   SGFProperty *move_prop = NULL; /* remember if we see a move property */
   int color; /* color of move to be made at this node. */
   
-  int boardsize = gnugo_get_boardsize();
   int m, n; /* Move from file. */
   int i, j; /* Move generated by GNU Go. */
 
@@ -138 +137 @@
     switch (sgf_prop->name) {
     case SGFAB:
       /* add black */
-      gnugo_add_stone(get_moveX(sgf_prop, boardsize),
-                      get_moveY(sgf_prop, boardsize), BLACK);
+      add_stone(POS(get_moveX(sgf_prop, board_size),
+                    get_moveY(sgf_prop, board_size)),
+                BLACK);
       break;
     case SGFAW:
       /* add white */
-      gnugo_add_stone(get_moveX(sgf_prop, boardsize),
-                      get_moveY(sgf_prop, boardsize), WHITE);
+      add_stone(POS(get_moveX(sgf_prop, board_size),
+                    get_moveY(sgf_prop, board_size)),
+                WHITE);
       break;
     case SGFB:
     case SGFW:
@@ -157 +158 @@
   if (!move_prop)
     return;
 
-  m = get_moveX(move_prop, boardsize);
-  n = get_moveY(move_prop, boardsize);
+  m = get_moveX(move_prop, board_size);
+  n = get_moveY(move_prop, board_size);
   color = (move_prop->name == SGFW) ? WHITE : BLACK;
 
   if (color == color_to_replay || color_to_replay == GRAY) {
@@ -173 +174 @@
         printf("GNU Go resigns ");
       else {
         mprintf("GNU Go plays %m ", i, j);
-        if (!gnugo_is_pass(i, j))
+        if (!is_pass(POS(i, j)))
           printf("(%.2f) ", potential_moves[POS(i, j)]);
       }
       mprintf("- Game move %m ", m, n);
-      if (!gnugo_is_pass(m, n) && potential_moves[POS(m, n)] > 0.0)
+      if (!is_pass(POS(m, n)) && potential_moves[POS(m, n)] > 0.0)
         printf("(%.2f) ", potential_moves[POS(m, n)]);
       printf("\n");
 
@@ -190 +191 @@
       if (resign)
         gg_snprintf(buf, 127, "GNU Go resigns - Game move %s (%.2f)",
                     location_to_string(POS(m, n)),
-                    gnugo_is_pass(m, n)
+                    is_pass(POS(m, n))
                     && potential_moves[POS(m, n)] < 0.0 ?
                         0 : potential_moves[POS(m, n)]);
       else {      
         gg_snprintf(buf, 127, "GNU Go plays %s (%.2f) - Game move %s (%.2f)",
                     location_to_string(POS(i, j)),
-                    gnugo_is_pass(i, j) ? 0 : potential_moves[POS(i, j)],
+                    is_pass(POS(i, j)) ? 0 : potential_moves[POS(i, j)],
                     location_to_string(POS(m, n)),
-                    gnugo_is_pass(m, n)
+                    is_pass(POS(m, n))
                     && potential_moves[POS(m, n)] < 0.0 ?
                         0 : potential_moves[POS(m, n)]);
         sgfCircle(node, i, j);
@@ -207 +208 @@
     else
       gg_snprintf(buf, 127, "GNU Go plays the same move %s (%.2f)",
                  location_to_string(POS(i, j)),
-                 gnugo_is_pass(i, j) ? 0 : potential_moves[POS(i, j)]);
+                 is_pass(POS(i, j)) ? 0 : potential_moves[POS(i, j)]);
     sgfAddComment(node, buf);
     sgffile_add_debuginfo(node, 0.0);
   }