Re: [gnugo-devel] Patch: semeai.c and filllib.c now 1-dimensional

[Gunnar Farneback]

Inge wrote:
> Here is a patch that makes filllib.c and semeai.c 1-dimensional.
> 
> Summary:
>  - filllib.c and semeai.c made 1-dimensional.
> 
> All clear?  :-)

We've done a bit of double work here so this patch conflicts horribly
with my last patch. A merge, sort of, looks like below, relative to
current CVS.

> Only in gnugo-3.1.10p1iw1/engine: filllib.c.save
> Only in gnugo-3.1.10p1iw1/engine: filllib.c~
> Binary files gnugo-3.1.10p1/engine/filllib.o and 
> gnugo-3.1.10p1iw1/engine/filllib.o differ
> Binary files gnugo-3.1.10p1/engine/fuseki.o and 
> gnugo-3.1.10p1iw1/engine/fuseki.o differ

Regardless of the existence of a .cvsignore file, you're very welcome
to cut out garbage from your patches. They don't break just by
deleting superfluous lines, you know.

/Gunnar

Index: engine/filllib.c
===================================================================
RCS file: /cvsroot/gnugo/gnugo/engine/filllib.c,v
retrieving revision 1.11
diff -u -r1.11 filllib.c
--- engine/filllib.c    2001/10/16 19:53:01     1.11
+++ engine/filllib.c    2001/10/16 21:06:12
@@ -48,7 +48,7 @@
 }
 
 
-/* Determine whether (m, n) effectively is a black or white point.
+/* Determine whether (pos) effectively is a black or white point.
  * The test for inessentiality is to avoid filling the liberties
  * around a killing nakade string.
  */
@@ -96,7 +96,7 @@
  * that several backfilling moves are ultimately necessary.
  *
  * If a move for color is found, return 1, otherwise return 0.
- * The move is returned in (*i, *j).
+ * The move is returned in (*move).
  */
 
 int 
@@ -134,16 +134,15 @@
       
       if (dragon[pos].matcher_status != DEAD) {
        for (k = 0; k < 12; k++) {
-         int di = deltai[k%8];
-         int dj = deltaj[k%8];
+         int d = delta[k%8];
+
          if (k >= 8) {
-           if (BOARD(m+di, n+dj) != EMPTY)
+           if (board[pos + d] != EMPTY)
              continue;
-           di *= 2;
-           dj *= 2;
+           d *= 2;
          }
-         if (BOARD(m+di, n+dj) == EMPTY)
-           potential_color[POS(m+di, n+dj)] |= board[pos];
+         if (board[pos + d] == EMPTY)
+           potential_color[pos + d] |= board[pos];
        }
       }
     }
@@ -165,15 +164,14 @@
        continue;
 
       /* Quick rejection based on preliminary test above. */
-      if (potential_color[POS(m, n)] != GRAY)
+      if (potential_color[pos] != GRAY)
        continue;
 
       /* Loop over the neighbors. */
       for (k = 0; k < 4; k++) {
-       int dm = deltai[k];
-       int dn = deltaj[k];
-       if (ON_BOARD(POS(m+dm, n+dn)))
-         analyze_neighbor(POS(m+dm, n+dn), &found_black, &found_white);
+       int d = delta[k];
+       if (ON_BOARD(pos + d))
+         analyze_neighbor(pos + d, &found_black, &found_white);
       }
       
       /* Do we have neighbors of both colors? */
@@ -190,7 +188,7 @@
        * 6. Move would violate confirm_safety.
        */
 
-      DEBUG(DEBUG_FILLLIB, "Filllib: Considering move at %m.\n", m, n);
+      DEBUG(DEBUG_FILLLIB, "Filllib: Considering move at %1m.\n", pos);
       
       /* Legal and tactically safe, play it if it passes
        * confirm_safety test, i.e. that it isn't a blunder which
@@ -235,7 +233,7 @@
        DEBUG(DEBUG_FILLLIB,
              "Filllib: Legal but not safe, looking for backfilling move.\n");
 
-       if (find_backfilling_move(POS(m, n), color, move)) {
+       if (find_backfilling_move(pos, color, move)) {
          DEBUG(DEBUG_FILLLIB, "Filllib: Backfilling move at %1m.\n", *move);
          /* In certain positions it may happen that an illegal move
           * is found. This probably only can happen if we try to play
@@ -281,11 +279,10 @@
         */
        DEBUG(DEBUG_FILLLIB, "Filllib: Illegal, looking for back-capture.\n");
        for (k = 0; k < 4; k++) {
-         int dm = deltai[k];
-         int dn = deltaj[k];
-         if (BOARD(m+dm, n+dn) == other
-             && worm[POS(m+dm, n+dn)].attack_codes[0] == WIN) {
-           *move = worm[POS(m+dm, n+dn)].attack_points[0];
+         int d = delta[k];
+         if (board[pos + d] == other
+             && worm[pos + d].attack_codes[0] == WIN) {
+           *move = worm[pos + d].attack_points[0];
            DEBUG(DEBUG_FILLLIB, "Filllib: Found at %1m.\n", *move);
            return 1;
          }
@@ -294,12 +291,11 @@
        DEBUG(DEBUG_FILLLIB,
              "Filllib: Nothing found, looking for ko back-capture.\n");
        for (k = 0; k < 4; k++) {
-         int dm = deltai[k];
-         int dn = deltaj[k];
-         if (BOARD(m+dm, n+dn) == other
-             && worm[POS(m+dm, n+dn)].attack_codes[0] != 0
-             && is_legal(worm[POS(m+dm, n+dn)].attack_points[0], color)) {
-           *move = worm[POS(m+dm, n+dn)].attack_points[0];
+         int d = delta[k];
+         if (board[pos + d] == other
+             && worm[pos + d].attack_codes[0] != 0
+             && is_legal(worm[pos + d].attack_points[0], color)) {
+           *move = worm[pos + d].attack_points[0];
            DEBUG(DEBUG_FILLLIB, "Filllib: Found at %1m.\n", *move);
            return 1;
          }
@@ -308,13 +304,12 @@
        DEBUG(DEBUG_FILLLIB,
              "Filllib: Nothing found, looking for threat to back-capture.\n");
        for (k = 0; k < 4; k++) {
-         int dm = deltai[k];
-         int dn = deltaj[k];
-         if (BOARD(m+dm, n+dn) == other
-             && worm[POS(m+dm, n+dn)].attack_codes[0] != 0) {
+         int d = delta[k];
+         if (board[pos + d] == other
+             && worm[pos + d].attack_codes[0] != 0) {
            /* Just pick some other liberty. */
            int libs[2];
-           if (findlib(POS(m+dm, n+dn), 2, libs) > 1) {
+           if (findlib(pos + d, 2, libs) > 1) {
              if (is_legal(libs[0], color))
                *move = libs[0];
              else if (is_legal(libs[1], color))
@@ -336,15 +331,15 @@
 /* The strategy for finding a backfilling move is to first identify
  * moves that
  *
- * 1. defends the position obtained after playing (m,n).
- * 2. captures a stone adjacent to our neighbors to (m,n), before
- *    (m,n) is played.
+ * 1. defends the position obtained after playing (move).
+ * 2. captures a stone adjacent to our neighbors to (move), before
+ *    (move) is played.
  *
- * Then we check which of these are legal before (m,n) is played. If
+ * Then we check which of these are legal before (move) is played. If
  * there is at least one, we take one of these arbitrarily as a
  * backfilling move.
  *
- * Now it may happen that (m,n) still isn't a safe move. In that case
+ * Now it may happen that (move) still isn't a safe move. In that case
  * we recurse to find a new backfilling move. To do things really
  * correctly we should also give the opponent the opportunity to keep
  * up the balance of the position by letting him do a backfilling move
@@ -369,7 +364,7 @@
   int acode;
   int saved_move = NO_MOVE;
   
-  /* Play (m,n) and identify all liberties and adjacent strings. */
+  /* Play (move) and identify all liberties and adjacent strings. */
   if (!trymove(move, color, "find_backfilling_move", move, EMPTY, NO_MOVE))
     return 0; /* This shouldn't happen, I believe. */
 
@@ -385,7 +380,7 @@
   /* Find neighbors. */
   neighbors = chainlinks(move, adjs);
 
-  /* Remove (m,n) again. */
+  /* Remove (move) again. */
   popgo();
   
   /* It's most fun to capture stones. Start by trying to take some
@@ -473,7 +468,7 @@
 }
 
 
-/* Confirm that (m, n) is a safe move for color. In addition to
+/* Confirm that (move) is a safe move for color. In addition to
  * calling the global confirm_safety(), this function also calls the
  * owl code to verify the strategical viability of the move.
  */
Index: engine/semeai.c
===================================================================
RCS file: /cvsroot/gnugo/gnugo/engine/semeai.c,v
retrieving revision 1.15
diff -u -r1.15 semeai.c
--- engine/semeai.c     2001/10/16 19:53:01     1.15
+++ engine/semeai.c     2001/10/16 21:06:16
@@ -86,7 +86,7 @@
   }
 }
 
-/* liberty_of_dragon(pos, dr) returns true if the vertex at (pos) is a
+/* liberty_of_dragon(pos, origin) returns true if the vertex at (pos) is a
  * liberty of the dragon with origin at (origin).
  */
 
@@ -171,12 +171,14 @@
 #endif
       if (dragon[your_dragon].owl_status == DEAD) {
        for (m = 0; m < board_size; m++)
-         for (n = 0; n < board_size; n++)
-           if (board[POS(m, n)] == board[your_dragon]
-               && is_same_dragon(POS(m, n), your_dragon)) {
-             dragon[POS(m, n)].owl_status = CRITICAL;
-             dragon[POS(m, n)].matcher_status = CRITICAL;
+         for (n = 0; n < board_size; n++) {
+           int pos = POS(m, n);
+           if (board[pos] == board[your_dragon]
+               && is_same_dragon(pos, your_dragon)) {
+             dragon[pos].owl_status = CRITICAL;
+             dragon[pos].matcher_status = CRITICAL;
            }
+         }
        DEBUG(DEBUG_SEMEAI,
              "changed owl_status and matcher_status of %1m to CRITICAL\n",
              your_dragon);
@@ -222,12 +224,14 @@
            my_dragon, dragon[your_dragon].owl_attack_point);
       if (dragon[my_dragon].owl_status == DEAD) {
        for (m = 0; m < board_size; m++)
-         for (n = 0; n < board_size; n++)
-           if (board[POS(m, n)] == board[my_dragon]
-               && is_same_dragon(POS(m, n), my_dragon)) {
-             dragon[POS(m, n)].owl_status = CRITICAL;
-             dragon[POS(m, n)].matcher_status = CRITICAL;
+         for (n = 0; n < board_size; n++) {
+           int pos = POS(m, n);
+           if (board[pos] == board[my_dragon]
+               && is_same_dragon(pos, my_dragon)) {
+             dragon[pos].owl_status = CRITICAL;
+             dragon[pos].matcher_status = CRITICAL;
            }
+         }
        DEBUG(DEBUG_SEMEAI,
              "changed owl_status and matcher_status of %1m to CRITICAL\n",
              my_dragon);
@@ -276,20 +280,21 @@
    */
   for (m = 0; m < board_size; m++)
     for (n = 0; n < board_size; n++) {
-      if (worm[POS(m, n)].origin == POS(m, n)
-         && worm[POS(m, n)].attack_codes[0] == WIN)
-       if (dragon[POS(m, n)].origin == my_dragon
-           || dragon[POS(m, n)].origin == your_dragon) {
+      int pos = POS(m, n);
+      if (worm[pos].origin == pos
+         && worm[pos].attack_codes[0] == WIN)
+       if (dragon[pos].origin == my_dragon
+           || dragon[pos].origin == your_dragon) {
          int adj;
          int adjs[MAXCHAIN];
          int r;
          
-         adj = chainlinks(POS(m, n), adjs);
+         adj = chainlinks(pos, adjs);
          for (r = 0; r < adj; r++) {
            int cpos = adjs[r];
            if (dragon[cpos].origin == my_dragon
                || dragon[cpos].origin == your_dragon)
-             if (owl_substantial(POS(m, n))) {
+             if (owl_substantial(pos)) {
                DEBUG(DEBUG_SEMEAI, "...tactical situation detected, 
exiting\n");
                return;
              }
@@ -300,11 +305,13 @@
   
   /* Mark the dragons as involved in semeai */
   for (i = 0; i < board_size; i++)
-    for (j = 0; j < board_size; j++)
-      if (is_same_dragon(POS(i, j), my_dragon)
-         || is_same_dragon(POS(i, j), your_dragon))
-       DRAGON2(POS(i, j)).semeai = 1;
-
+    for (j = 0; j < board_size; j++) {
+      int pos = POS(i, j);
+      if (is_same_dragon(pos, my_dragon)
+         || is_same_dragon(pos, your_dragon))
+       DRAGON2(pos).semeai = 1;
+    }
+  
   /* First we try to determine the number of liberties of each
    * dragon, and the number of common liberties. We subtract
    * 1 minus the number of worms of the dragon from the liberty
@@ -315,17 +322,18 @@
    */
   for (i = 0; i < board_size; i++)
     for (j = 0; j < board_size; j++) {
-      if (board[POS(i, j)]
-         && worm[POS(i, j)].origin == POS(i, j)) {
-       if (is_same_dragon(POS(i, j), my_dragon))
+      int pos = POS(i, j);
+      if (board[pos]
+         && worm[pos].origin == pos) {
+       if (is_same_dragon(pos, my_dragon))
          mylibs--;
-       if (is_same_dragon(POS(i, j), your_dragon))
+       if (is_same_dragon(pos, your_dragon))
          yourlibs--;
       }
-      else if (board[POS(i, j)] == EMPTY) {
-       if (liberty_of_dragon(POS(i, j), your_dragon)) {
+      else if (board[pos] == EMPTY) {
+       if (liberty_of_dragon(pos, your_dragon)) {
          yourlibs ++;
-         if (liberty_of_dragon(POS(i, j), my_dragon)) {
+         if (liberty_of_dragon(pos, my_dragon)) {
            commonlibs++;
            mylibs++;
            commonlibi = i;
@@ -336,7 +344,7 @@
            yourlibj = j;
          }
        }
-       else if (liberty_of_dragon(POS(i, j), my_dragon))
+       else if (liberty_of_dragon(pos, my_dragon))
          mylibs++;
       }
     }
@@ -602,21 +610,23 @@
     }
     else {
       for (i = 0; i < board_size-1; i++)
-       for (j = 0; j < board_size-1; j++)
-         if (liberty_of_dragon(POS(i, j), your_dragon) 
-             && !liberty_of_dragon(POS(i, j), my_dragon)
-             && safe_move(POS(i, j), color)) {
+       for (j = 0; j < board_size-1; j++) {
+         int pos = POS(i, j);
+         if (liberty_of_dragon(pos, your_dragon) 
+             && !liberty_of_dragon(pos, my_dragon)
+             && safe_move(pos, color)) {
            /* add move reasons for EVERY outside liberty where we can
              * play safely. A move to win a semeai might not be a
              * safe move if it is inside the opponent's eyespace. 
              * However we hope that the reading code can analyze the
              * semeai in cases where every safe liberty has been filled.
             */
-           add_appropriate_semeai_moves(POS(i, j), my_dragon, your_dragon,
+           add_appropriate_semeai_moves(pos, my_dragon, your_dragon,
                                         my_status, your_status,
                                         margin_of_safety);
            found_one = 1;
          }
+       }
       if (!found_one) {
        /* No outside liberties --- look for common liberties.
         * Filling a common liberty is usually bad but if our 
@@ -626,12 +636,14 @@
         * be a safe move.
         */
        for (i = 0; i < board_size-1; i++)
-         for (j = 0; j < board_size-1; j++)
-           if (liberty_of_dragon(POS(i, j), your_dragon)
-               && safe_move(POS(i, j), color))
-             add_appropriate_semeai_moves(POS(i, j), my_dragon, your_dragon,
+         for (j = 0; j < board_size-1; j++) {
+           int pos = POS(i, j);
+           if (liberty_of_dragon(pos, your_dragon)
+               && safe_move(pos, color))
+             add_appropriate_semeai_moves(pos, my_dragon, your_dragon,
                                           my_status, your_status,
                                           margin_of_safety);
+         }
       }
     }
   }
@@ -724,7 +736,7 @@
 }
 
 /* Helper function for small_semeai. Tries to resolve the
- * semeai between (i,j) and (m,n), possibly revising points
+ * semeai between (str1) and (str2), possibly revising points
  * of attack and defense.
  */