Ticket #32: gunnar_7_8.1

Index: interface/interface.h
===================================================================
RCS file: /cvsroot/gnugo/gnugo/interface/interface.h,v
retrieving revision 1.18
diff -u -r1.18 interface.h
--- interface/interface.h       12 Jun 2005 09:34:14 -0000      1.18
+++ interface/interface.h       9 Oct 2005 20:41:21 -0000
@@ -37,7 +37,7 @@
              int gtp_initial_orientation);
 void play_gmp(Gameinfo *gameinfo, int simplified);
 void play_solo(Gameinfo *gameinfo, int benchmark);
-void play_replay(Gameinfo *gameinfo, int color_to_test);
+void play_replay(SGFTree *tree, int color_to_test);
 
 void load_and_analyze_sgf_file(Gameinfo *gameinfo);
 void load_and_score_sgf_file(SGFTree *tree, Gameinfo *gameinfo,
Index: interface/main.c
===================================================================
RCS file: /cvsroot/gnugo/gnugo/interface/main.c,v
retrieving revision 1.119
diff -u -r1.119 main.c
--- interface/main.c    7 Oct 2005 23:22:31 -0000       1.119
+++ interface/main.c    9 Oct 2005 20:41:21 -0000
@@ -1024,7 +1024,7 @@
       fprintf(stderr, "You must use -l infile with replay mode.\n");
       exit(EXIT_FAILURE);
     }
-    play_replay(&gameinfo, replay_color);
+    play_replay(&sgftree, replay_color);
     break;
     
   case MODE_LOAD_AND_ANALYZE:
Index: interface/play_test.c
===================================================================
RCS file: /cvsroot/gnugo/gnugo/interface/play_test.c,v
retrieving revision 1.22
diff -u -r1.22 play_test.c
--- interface/play_test.c       5 Oct 2005 16:32:12 -0000       1.22
+++ interface/play_test.c       9 Oct 2005 20:41:21 -0000
@@ -32,10 +32,8 @@
 #include "gg_utils.h"
 #include "liberty.h"
 
-static void replay_node(SGFNode *node, int color_to_test);
-
-static float replay_score;
-static float total_score;
+static void replay_node(SGFNode *node, int color_to_test, float *replay_score,
+                       float *total_score);
 
 
 /* --------------------------------------------------------------*/
@@ -43,28 +41,25 @@
 /* --------------------------------------------------------------*/
 
 void
-play_replay(Gameinfo *gameinfo, int color_to_replay)
+play_replay(SGFTree *tree, int color_to_replay)
 {
-  int tmpi;
-  float tmpf;
   char *tmpc = NULL;
+  float replay_score = 0.0;
+  float total_score = 0.0;
 
-  SGFTree tree = gameinfo->game_record;
-  SGFNode *node = tree.root;
-
-  /* Get the board size. */
-  if (!sgfGetIntProperty(node, "SZ", &tmpi)) {
-    fprintf(stderr, "Couldn't find the size (SZ) attribute!\n");
-    exit(EXIT_FAILURE);
-  }
-
-  gnugo_clear_board(tmpi);
-
-  /* Get the komi. */
-  if (sgfGetFloatProperty(node, "KM", &tmpf))
-    komi = tmpf;
+  SGFNode *node = tree->root;
 
+  /* Board size and komi are already set up correctly since the game
+   * has already been loaded before this function is called. Now we
+   * only have to clear the board before starting over.
+   */
+  clear_board();
+ 
   if (!quiet) {
+    printf("Board Size:   %d\n", board_size);
+    if (sgfGetCharProperty(node, "HA", &tmpc))
+      printf("Handicap:     %s\n", tmpc);
+    printf("Komi:         %.1f\n", komi);
     if (sgfGetCharProperty(node, "RU", &tmpc))
       printf("Ruleset:      %s\n", tmpc);
     if (sgfGetCharProperty(node, "GN", &tmpc))
@@ -79,11 +74,8 @@
       printf("Black Player: %s\n", tmpc);
     if (sgfGetCharProperty(node, "PW", &tmpc))
       printf("White Player: %s\n", tmpc);
-
-    gameinfo_print(gameinfo);
-
-    replay_score = 0.0;
-    total_score = 0.0;
+    if (sgfGetCharProperty(node, "RE", &tmpc))
+      printf("Result:       %s\n", tmpc);
   }
 
   /*
@@ -92,42 +84,43 @@
    * we need to check what move GNU Go would make, and see if it is OK. 
    */
   while (node) {
-    replay_node(node, color_to_replay);
-    sgffile_output(&tree);
+    replay_node(node, color_to_replay, &replay_score, &total_score);
+    sgffile_output(tree);
     node = node->child;
   }
 
-  if (!quiet) {
-    printf("\nGlobal score: %.2f / %.2f", replay_score, total_score);
-  }
+  if (!quiet)
+    printf("Global score: %.2f / %.2f", replay_score, total_score);
 
   if (showtime) {
-      gprintf("\nSLOWEST MOVE: %d at %1m ", slowest_movenum, slowest_move);
-      fprintf(stderr, "(%.2f seconds)\n", slowest_time);
-      fprintf(stderr, "\nAVERAGE TIME: %.2f seconds per move\n",
-             total_time / movenum);
-      fprintf(stderr, "\nTOTAL TIME: %.2f seconds\n",
-             total_time);
+    gprintf("SLOWEST MOVE: %d at %1m ", slowest_movenum, slowest_move);
+    fprintf(stderr, "(%.2f seconds)\n", slowest_time);
+    fprintf(stderr, "AVERAGE TIME: %.2f seconds per move\n",
+           total_time / movenum);
+    fprintf(stderr, "TOTAL TIME: %.2f seconds\n",
+           total_time);
   }
 }
 
 
+#define BUFSIZE 128
 
 /*
  * Handle this node.
  */
 
 static void
-replay_node(SGFNode *node, int color_to_replay)
+replay_node(SGFNode *node, int color_to_replay, float *replay_score,
+           float *total_score)
 {
   SGFProperty *sgf_prop;  /* iterate over properties of the node */
   SGFProperty *move_prop = NULL; /* remember if we see a move property */
   int color; /* color of move to be made at this node. */
   
-  int m, n; /* Move from file. */
-  int i, j; /* Move generated by GNU Go. */
+  int old_move; /* The move played in the file. */
+  int new_move; /* The move generated by GNU Go. */
 
-  char buf[127];
+  char buf[BUFSIZE];
 
   /* Handle any AB / AW properties, and note presence
    * of move properties.
@@ -158,63 +151,67 @@
   if (!move_prop)
     return;
 
-  m = get_moveX(move_prop, board_size);
-  n = get_moveY(move_prop, board_size);
+  old_move = POS(get_moveX(move_prop, board_size),
+                get_moveY(move_prop, board_size));
   color = (move_prop->name == SGFW) ? WHITE : BLACK;
 
   if (color == color_to_replay || color_to_replay == GRAY) {
+    float new_move_value = 0.0;
+    float old_move_value = 0.0;
+  
     /* Get a move from the engine for color. */
     int resign;
-    gnugo_genmove(&i, &j, color, &resign);
+    new_move = genmove(color, NULL, &resign);
+    
+    /* Pick up the relevant values from the potential_moves[] array. */
+    if (new_move != PASS_MOVE)
+      new_move_value = potential_moves[new_move]; 
+    if (old_move != PASS_MOVE)
+      old_move_value = potential_moves[old_move];
+    
     /* Now report on how well the computer generated the move. */
-    if (i != m || j != n || !quiet) {
+    if (new_move != old_move || !quiet) {
       mprintf("Move %d (%C): ", movenum + 1, color);
     
       if (resign)
        printf("GNU Go resigns ");
       else {
-       mprintf("GNU Go plays %m ", i, j);
-       if (!is_pass(POS(i, j)))
-         printf("(%.2f) ", potential_moves[POS(i, j)]);
+       mprintf("GNU Go plays %1m ", new_move);
+       if (new_move != PASS_MOVE)
+         printf("(%.2f) ", new_move_value);
       }
-      mprintf("- Game move %m ", m, n);
-      if (!is_pass(POS(m, n)) && potential_moves[POS(m, n)] > 0.0)
-       printf("(%.2f) ", potential_moves[POS(m, n)]);
+      
+      mprintf("- Game move %1m ", old_move);
+      if (new_move != PASS_MOVE && old_move_value > 0.0)
+       printf("(%.2f) ", old_move_value);
       printf("\n");
 
-      if (!quiet) {
-       replay_score += (potential_moves[POS(i, j)] - potential_moves[POS(m, n)]);
-       total_score += potential_moves[POS(i, j)];
-      }
+      *replay_score += new_move_value - old_move_value;
+      *total_score += new_move_value;
     }
-    if (i != m || j != n) {
+    
+    if (new_move != old_move) {
       if (resign)
-       gg_snprintf(buf, 127, "GNU Go resigns - Game move %s (%.2f)",
-                   location_to_string(POS(m, n)),
-                   is_pass(POS(m, n))
-                   && potential_moves[POS(m, n)] < 0.0 ?
-                       0 : potential_moves[POS(m, n)]);
+       gg_snprintf(buf, BUFSIZE, "GNU Go resigns - Game move %s (%.2f)",
+                   location_to_string(old_move), old_move_value);
       else {      
-       gg_snprintf(buf, 127, "GNU Go plays %s (%.2f) - Game move %s (%.2f)",
-                   location_to_string(POS(i, j)),
-                   is_pass(POS(i, j)) ? 0 : potential_moves[POS(i, j)],
-                   location_to_string(POS(m, n)),
-                   is_pass(POS(m, n))
-                   && potential_moves[POS(m, n)] < 0.0 ?
-                       0 : potential_moves[POS(m, n)]);
-       sgfCircle(node, i, j);
+       gg_snprintf(buf, BUFSIZE,
+                   "GNU Go plays %s (%.2f) - Game move %s (%.2f)",
+                   location_to_string(new_move), new_move_value,
+                   location_to_string(old_move), old_move_value);
+       sgfCircle(node, I(new_move), J(new_move));
       }
     }
     else
-      gg_snprintf(buf, 127, "GNU Go plays the same move %s (%.2f)",
-                 location_to_string(POS(i, j)),
-                 is_pass(POS(i, j)) ? 0 : potential_moves[POS(i, j)]);
+      gg_snprintf(buf, BUFSIZE, "GNU Go plays the same move %s (%.2f)",
+                 location_to_string(new_move), new_move_value);
+    
     sgfAddComment(node, buf);
     sgffile_add_debuginfo(node, 0.0);
   }
 
   /* Finally, do play the move from the file. */
-  gnugo_play_move(m, n, color);
+  play_move(old_move, color);
 }