Ticket #145: worm.c.patch

gnugo/engine/worm.c

@@ -106 +106 @@
   gg_assert(stackp == 0);
 
   /* Count liberties of different orders and initialize cutstone fields. */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (IS_STONE(board[pos]) && is_worm_origin(pos, pos)) {
-      int lib1, lib2, lib3, lib4;
+      int lib1;
+          int lib2;
+          int lib3;
+          int lib4;
       
       ping_cave(pos, &lib1, &lib2, &lib3, &lib4);
       ASSERT1(worm[pos].liberties == lib1, pos);
@@ -119 +122 @@
       worm[pos].cutstone2 = 0;
       propagate_worm(pos);
     }
-  }
+  )
   
   gg_assert(stackp == 0);
 
@@ -172 +175 @@
    * possible we also need the old concept for correct handling of lunches.
    */
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     int w1 = NO_MOVE;
     int w2 = NO_MOVE;
     int k;
@@ -187 +190 @@
     /* Try to find two adjacent worms (w1) and (w2) 
      * of opposite colour from (pos).
      */
-    for (pos2 = BOARDMIN; pos2 < BOARDMAX; pos2++) {
+    scan_board(pos2,
       /* Work only with the opposite color from (pos). */
       if (board[pos2] != OTHER_COLOR(board[pos])) 
         continue;
@@ -207 +210 @@
         else if (!is_same_worm(pos2, w1))
           w2 = worm[pos2].origin;
       }
-    }
+        )
     
     /* 
      *  We now verify the definition of cutting stones. We have
@@ -225 +228 @@
       DEBUG(DEBUG_WORMS, "Worm at %1m has w1 %1m and w2 %1m, cutstone %d\n",
             pos, w1, w2, worm[pos].cutstone);
     }
-  }
+  )
   
   gg_assert(stackp == 0);
   
   /* Set the genus of all worms. */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (IS_STONE(board[pos]) && is_worm_origin(pos, pos)) {
       worm[pos].genus = genus(pos);
       propagate_worm(pos);
     }
-  }
+  )
   gg_assert(stackp == 0);
 
   /* Now we try to improve the values of worm.attack and worm.defend.
@@ -251 +254 @@
     memset(moves_to_try, 0, sizeof(moves_to_try));
 
     /* Find which colors to try at what points. */
-    for (str = BOARDMIN; str < BOARDMAX; str++) {
+    scan_board(str,
       if (IS_STONE(board[str]) && is_worm_origin(str, str)) {
         color = board[str];
         moves_to_try[worm[str].defense_points[0]] |= color;
         moves_to_try[worm[str].attack_points[0]] |= OTHER_COLOR(color);
       }
-    }
+        )
 
     /* Loop over the board and over the colors and try the moves found
      * in the previous loop.
      */
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-      if (!ON_BOARD(pos))
-        continue;
+    scan_board(pos,
 
       for (color = WHITE; color <= BLACK; color++) {
         if (!(moves_to_try[pos] & color))
@@ -286 +287 @@
         /* Now we try to find a group which is saved or attacked as well
          * by this move.
          */
-        for (str = BOARDMIN; str < BOARDMAX; str++) {
+        scan_board(str,
           if (!IS_STONE(board[str])
               || !is_worm_origin(str, str))
             continue;
@@ -376 +377 @@
               }
             }
           }
-        }
+        )
         decrease_depth_values();
         popgo();
       }
-    }
+        )
   }
   
   gg_assert(stackp == 0);
@@ -403 +404 @@
    */
 
   /* First look for vertical neighbors. */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (IS_STONE(board[pos])
         && IS_STONE(board[SOUTH(pos)])
         && !is_same_worm(pos, SOUTH(pos))) {
@@ -421 +422 @@
         }
       }
     }
-  }
+  )
   
   /* Then look for horizontal neighbors. */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (IS_STONE(board[pos])
         && IS_STONE(board[EAST(pos)])
         && !is_same_worm(pos, EAST(pos))) {
@@ -442 +443 @@
         }
       }
     }
-  }
+  )
   
   gg_assert(stackp == 0);
   
   /* Find adjacent worms that can be easily captured, aka lunches. */
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     int lunch;
     
     if (!IS_STONE(board[pos]) || !is_worm_origin(pos, pos))
@@ -464 +465 @@
       worm[pos].lunch = NO_MOVE;
     
     propagate_worm(pos);
-  }
+  )
   
   if (!disable_threat_computation)
     find_worm_threats();
@@ -492 +493 @@
    * opponent's eye space.
    */
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (IS_STONE(board[pos])
         && worm[pos].origin == pos
         && worm[pos].genus == 0
@@ -507 +508 @@
         propagate_worm(pos);
       }
     }
-  }
+  )
 }
 
 
@@ -526 +527 @@
   memset(worm, 0 , sizeof(worm));
 
   /* Initialize the worm data for each worm. */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-    if (ON_BOARD(pos))
-      worm[pos].origin = NO_MOVE;
+  scan_board(pos,
+    worm[pos].origin = NO_MOVE;
+  )
   
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (!ON_BOARD(pos) || worm[pos].origin != NO_MOVE)
+  scan_board(pos,
+    if (worm[pos].origin != NO_MOVE)
       continue;
     worm[pos].color = board[pos];
     worm[pos].origin = pos;
@@ -544 +545 @@
       worm[pos].size = countstones(pos);
       propagate_worm(pos);
     }
-  }
+  )
 }
 
 
@@ -596 +597 @@
   int r;
     
   /* Initialize arrays. */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (!ON_BOARD(pos))
-      continue;
+  scan_board(pos,
 
     for (k = 0; k < 2*(board_size-1); k++)
       worms[pos][k] = NO_MOVE;
@@ -612 +611 @@
     }
     else
       distance[pos] = -1;
-  }
+  )
   
   dist = 0;
   found_one = 1;
   while (found_one && dist <= max_distance) {
     found_one = 0;
     dist++;
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-      if (!ON_BOARD(pos) || distance[pos] != -1)
+    scan_board(pos,
+      if (distance[pos] != -1)
         continue; /* already claimed */
 
       for (r = 0; r < 4; r++) {
@@ -644 +643 @@
           }
         }
       }
-    }
+        )
   }
 
   /* Compute the effective sizes but only when all worms are considered. */
   if (color == (BLACK | WHITE)) {
     /* Distribute (fractional) contributions to the worms. */
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-      if (!ON_BOARD(pos))
-        continue;
+    scan_board(pos,
       
       for (k = 0; k < nworms[pos]; k++) {
         int w = worms[pos][k];
@@ -661 +658 @@
         else
           worm[w].effective_size += 1.0;
       }
-    }
+        )
     
     /* Propagate the effective size values all over the worms. */
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+    scan_board(pos,
       if (IS_STONE(board[pos]) && is_worm_origin(pos, pos))
-        propagate_worm(pos);
+            propagate_worm(pos);
+        )
   }
 
   /* Fill in the appropriate close_*_worms (cw) and
    * number_close_*_worms (ncw) arrays.
    */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (!ON_BOARD(pos))
-      continue;
-
+  scan_board(pos,
     if (nworms[pos] > MAX_CLOSE_WORMS)
       ncw[pos] = 0;
     else
@@ -683 +678 @@
 
     for (k = 0; k < ncw[pos]; k++)
       cw[pos][k] = worms[pos][k];
-  }
+  )
 }
 
 /* Identify worms which are unconditionally uncapturable in the
@@ -702 +697 @@
   for (color = WHITE; color <= BLACK; color++) {
     unconditional_life(unconditional_territory, color);
 
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-      if (!ON_BOARD(pos) || !unconditional_territory[pos])
+    scan_board(pos,
+      if (!unconditional_territory[pos])
         continue;
         
       if (board[pos] == color) {
@@ -719 +714 @@
       }
       else
         worm[pos].unconditional_status = DEAD;
-    }
+        )
   }
   gg_assert(stackp == 0);
 }
@@ -742 +737 @@
   int other;
 
    /* 1. Start with finding attack points. */
-  for (str = BOARDMIN; str < BOARDMAX; str++) {
+  scan_board(str,
     if (!IS_STONE(board[str]) || !is_worm_origin(str, str))
       continue;
 
@@ -762 +757 @@
             str, attack_point);
       change_attack(str, attack_point, acode);
     }
-  }
+  )
   gg_assert(stackp == 0);
   
   /* 2. Use pattern matching to find a few more attacks. */
@@ -770 +765 @@
   gg_assert(stackp == 0);
   
   /* 3. Now find defense moves. */
-  for (str = BOARDMIN; str < BOARDMAX; str++) {
+  scan_board(str,
     if (!IS_STONE(board[str]) || !is_worm_origin(str, str))
       continue;
 
@@ -801 +796 @@
           }
       }
     }
-  }
+  )
   gg_assert(stackp == 0);
 
   /* 4. Use pattern matching to find a few more defense moves. */
@@ -814 +809 @@
    *    matching and by trying whether each attack or defense point
    *    attacks or defends other strings.
    */
-  for (str = BOARDMIN; str < BOARDMAX; str++) {
+  scan_board(str,
     color = board[str];
     if (!IS_STONE(color) || !is_worm_origin(str, str))
       continue;
@@ -860 +855 @@
           }
       }
     }
-  }
+  )
   gg_assert(stackp == 0);
 }
 
@@ -880 +875 @@
   int l;
   int color;
   
-  for (str = BOARDMIN; str < BOARDMAX; str++) {
+  scan_board(str,
     color = board[str];
     if (!IS_STONE(color) || !is_worm_origin(str, str))
       continue;
@@ -969 +964 @@
       
       /* FIXME: Try other moves also (patterns?). */
     }
-  }
+  )
 }
 
 
@@ -990 +985 @@
   ASSERT1(stackp == 0, str);
 
   *lunch = NO_MOVE;
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (board[pos] != OTHER_COLOR(board[str]))
       continue;
     for (k = 0; k < 8; k++) {
@@ -1013 +1008 @@
         break;
       }
     }
-  }
+  )
   
   if (*lunch != NO_MOVE)
     return 1;
@@ -1221 +1216 @@
   ASSERT_ON_BOARD1(str);
   ASSERT1(IS_STONE(worm[str].color), str);
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+  scan_board(pos,
     if (board[pos] == board[str] && is_same_worm(pos, str)
         && pos != str)
       worm[pos] = worm[str];
+  )
 }
 
 
@@ -1237 +1233 @@
   int pos;
   int k;
   
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (!ON_BOARD(pos) || board[pos] == EMPTY)
+  scan_board(pos,
+    if (board[pos] == EMPTY)
       continue;
 
     if (!is_worm_origin(pos, pos))
@@ -1266 +1262 @@
                                   worm[pos].defense_threat_codes[k]);
       }
     }
-  }
+  )
 }
 
 
@@ -1323 +1319 @@
    * opposite color, or one stone and the edge.
    */
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-    if (ON_BOARD(pos)
-        && mse[pos]
+  scan_board(pos,
+    if (mse[pos]
         && (((      !ON_BOARD(SOUTH(pos)) || board[SOUTH(pos)] == other)
              && (   !ON_BOARD(NORTH(pos)) || board[NORTH(pos)] == other))
             || ((   !ON_BOARD(WEST(pos))  || board[WEST(pos)]  == other)
                 && (!ON_BOARD(EAST(pos))  || board[EAST(pos)]  == other))))
       mse[pos] = 0;
+  )
   
   *lib2 = 0;
   memset(mrc, 0, sizeof(mrc));
@@ -1408 +1404 @@
   int gen = -1;
 
   memset(mg, 0, sizeof(mg));
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (ON_BOARD(pos)
-        && !mg[pos]
+  scan_board(pos,
+    if (!mg[pos]
         && (board[pos] == EMPTY || !is_same_worm(pos, str))) {
       markcomponent(str, pos, mg);
       gen++;
     }
-  }
+  )
 
   return gen;
 }
@@ -1707 +1702 @@
 get_lively_stones(int color, signed char safe_stones[BOARDMAX])
 {
   int ii;
-  memset(safe_stones, 0, BOARDMAX * sizeof(*safe_stones));
-  for (ii = BOARDMIN; ii < BOARDMAX; ii++)
-    ASSERT1(safe_stones[ii] == 0, ii);
-  for (ii = BOARDMIN; ii < BOARDMAX; ii++)
+  memset(safe_stones, 0, BOARDMAX * sizeof(signed char));
+  
+  scan_board(ii,
     if (IS_STONE(board[ii])
         && worm[ii].origin == ii) {
       if (worm[ii].attack_codes[0] == 0
           || (board[ii] == color
               && worm[ii].defense_codes[0] != 0))
         mark_string(ii, safe_stones, 1);
-    }
+        }
+  )
 }