Ticket #145: owl.c.patch

gnugo/engine/owl.c

@@ -453 +453 @@
   sgf_dumptree = NULL;
   if (verbose > 0)
     verbose--;
-  for (str = BOARDMIN; str < BOARDMAX; str++) 
-    if (ON_BOARD(str) && ms[str] && worm[str].origin == str) {
+  scan_board(str,
+    if (ms[str] && worm[str].origin == str) {
       int adj;
       int adjs[MAXCHAIN];
       int k;
@@ -493 +493 @@
         semeai_worms[s_worms++] = str;
         DEBUG(DEBUG_SEMEAI, "semeai worm: %1m\n", str);
       }
-    }
+        }
+  )
   verbose = save_verbose;
   sgf_dumptree = save_sgf_dumptree;
 
@@ -981 +982 @@
   if (!you_look_alive
       && !safe_outside_liberty_found && moves[0].value < 110) {
     int pos;
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-      if (!ON_BOARD(pos))
-        continue;
+    scan_board(pos,
       
       if (board[pos] == EMPTY && !mw[pos]) {
         if (liberty_of_goal(pos, owlb)) {
@@ -1010 +1009 @@
           }
         }
       }
-    }
+        )
   }
 
   /* Add the best liberty filling move available. We first want to
@@ -1516 +1515 @@
   /* Never try to fill opponent's eyes which contain our dragon.  This
    * is nothing else than suicide.
    */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (ON_BOARD(pos) && owla->goal[pos])
+  scan_board(pos,
+    if (owla->goal[pos])
       mw[owlb->my_eye[pos].origin] = 0;
-  }
+  )
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (board[pos] == EMPTY) {
       int origin = owlb->my_eye[pos].origin;
 
@@ -1546 +1545 @@
           return pos;
       }
     }
-  }
+  )
 
   return NO_MOVE;
 }
@@ -1573 +1572 @@
   ASSERT1(board[move] == EMPTY, move);
   verbose = 0;
   if (safe_move(move, color)) {
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+    scan_board(pos,
       if (IS_STONE(board[pos])
           && pos == find_origin(pos)) {
         if (owla->goal[pos])
@@ -1581 +1580 @@
         if (owlb->goal[pos])
           net += 100*countlib(pos);       
       }
-    }
+        )
     if (!trymove(move, color, NULL, 0)) {
       verbose = save_verbose;
       return 0;
     }
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+    scan_board(pos,
       if (IS_STONE(board[pos])
           && pos == find_origin(pos)) {
         if (owla->goal[pos]
@@ -1595 +1594 @@
         if (owlb->goal[pos])
           net -= 100*countlib(pos);
       }
-    }
+        )
 
     increase_depth_values();
     for (k = 0; k < s_worms; k++) {
@@ -2360 +2359 @@
            */
           
           if (board[target] == EMPTY) {
-            for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+            scan_board(pos,
               if (IS_STONE(board[pos]) && owl->goal[pos] == 1) {
                 origin = find_origin(pos);
                 break;
               }
-            }
+                )
             
             if (origin == NO_MOVE
                 || do_owl_attack(origin, NULL, NULL, owl, 0)) {
@@ -2655 +2654 @@
 
         /* If the goal is small, try a tactical defense. */
 
-        for (k = BOARDMIN; k < BOARDMAX; k++)
-          if (ON_BOARD(k))
-            goalcount += owl->goal[k];
+        scan_board(k,
+          goalcount += owl->goal[k];
+        )
 
         if (goalcount < 5) {
 
@@ -3087 +3086 @@
   owl_find_relevant_eyespaces(owl, mw, mz);
 
   /* Reset halfeye data. Set topological eye value to something big. */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (ON_BOARD(pos)) {
-      owl->half_eye[pos].type = 0;
-      owl->half_eye[pos].value = 10.0;
-    }
-  }
+  scan_board(pos,
+    owl->half_eye[pos].type = 0;
+    owl->half_eye[pos].value = 10.0;
+  )
   
   /* Find topological half eyes and false eyes. */
   find_half_and_false_eyes(color, eye, owl->half_eye, mw);
@@ -3106 +3103 @@
   
   set_eyevalue(probable_eyes, 0, 0, 0, 0);
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (ON_BOARD(pos) && mw[pos] > 1) {
+  scan_board(pos,
+    if (mw[pos] > 1) {
       int value = 0;
       const char *reason = "";
       compute_eyes_pessimistic(pos, &eyevalue, &pessimistic_min,
@@ -3132 +3129 @@
        * that the pessimistic min is 0.
        */
       if (pessimistic_min > 0) {
-        for (pos2 = BOARDMIN; pos2 < BOARDMAX; pos2++) {
-          if (ON_BOARD(pos2)
-              && eye[pos2].origin == pos
+        scan_board(pos2,
+          if (eye[pos2].origin == pos
               && owl->inessential[pos2]) {
             pessimistic_min = 0;
             break;
           }
-        }
+        )
       }
 #endif
 
@@ -3263 +3259 @@
       }
       num_eyes++;
     }
-  }
+  )
 
   /* Sniff each lunch for nutritional value. The assumption is that
    * capturing the lunch is gote, therefore the number of half eyes
@@ -3411 +3407 @@
 
   memset(mw, 0, BOARDMAX * sizeof(mw[0]));
   memset(mz, 0, BOARDMAX * sizeof(mz[0]));
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (board[pos] == owl->color) {
       for (k = 0; k < 8; k++) {
         int pos2 = pos + delta[k];
@@ -3425 +3421 @@
         }
       }
     }
-  }
+  )
 }
 
 /* Case 1.
@@ -4037 +4033 @@
    * and calculate initial chain values (as if all patterns passed
    * constraint validation).
    */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (list->first_pattern_index[pos] != -1) {
       struct matched_pattern_data *pattern_data
         = &list->pattern_list[list->first_pattern_index[pos]];
@@ -4045 +4041 @@
       pattern_data->value = valuate_combinable_pattern_chain(list, pos);
       list->pattern_heap[list->heap_num_patterns++] = pattern_data;
     }
-  }
+  )
 
   if (list->heap_num_patterns > 0)
     pattern_list_build_heap(list);
@@ -4579 +4575 @@
   ASSERT1(bpos == NO_MOVE || board[bpos] == color, bpos);
 
   if (new_dragons == NULL) {
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-      if (ON_BOARD(pos)) {
-        if (is_same_dragon(pos, apos) || is_same_dragon(pos, bpos))
-          owl->goal[pos] = 1;
-        else
-          owl->goal[pos] = 0;
-      }
+    scan_board(pos,
+          if (is_same_dragon(pos, apos) || is_same_dragon(pos, bpos))
+            owl->goal[pos] = 1;
+          else
+            owl->goal[pos] = 0;
+        )
   }
   else {
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-      if (ON_BOARD(pos)) {
-        if (IS_STONE(board[pos])
-            && (new_dragons[pos] == new_dragons[apos]
-                || new_dragons[pos] == new_dragons[bpos]))
-          owl->goal[pos] = 1;
-        else
-          owl->goal[pos] = 0;
-      }
+    scan_board(pos,
+          if (IS_STONE(board[pos])
+              && (new_dragons[pos] == new_dragons[apos]
+                  || new_dragons[pos] == new_dragons[bpos]))
+            owl->goal[pos] = 1;
+          else
+            owl->goal[pos] = 0;
+        )
   }
 
   memcpy(owl->cumulative_goal, owl->goal, sizeof(owl->goal));
@@ -4617 +4611 @@
   
   ASSERT1(bpos == NO_MOVE || board[bpos] == color, bpos);
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-    if (ON_BOARD(pos)) {
+  scan_board(pos,
       if (is_same_worm(pos, apos) || is_same_worm(pos, bpos))
         owl->goal[pos] = 1;
       else
         owl->goal[pos] = 0;
-    }
+  )
 
   owl->color = color;
 }
@@ -4645 +4638 @@
   memset(owl->neighbors, 0, sizeof(owl->neighbors));
 
   /* Find all friendly neighbors of the dragon in goal. */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (board[pos] == color && owl->goal[pos]) {
       for (k = 0; k < 4; k++) {
         if (board[pos + delta[k]] == EMPTY
@@ -4664 +4657 @@
           mark_string(pos2, owl->neighbors, 1);
       }
     }
-  }
+  )
 
   /* First find all boundary strings (including those adjacent not to
    * the goal dragon, but one of its neighbors).
    */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+  scan_board(pos,
     if (board[pos] == other && !owl->boundary[pos]) {
       for (k = 0; k < 8; k++)
         if (ON_BOARD(pos + delta[k])
@@ -4677 +4670 @@
           mark_string(pos, owl->boundary, 1);
           break;
         }
-    }
+        }
+  )
 
   /* Upgrade the mark of a boundary string if it adjoins a safe
    * friendly dragon.
    */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+  scan_board(pos,
     if (owl->boundary[pos] == 1) {
       for (k = 0; k < 8; k++) {
         int pos2 = pos + delta[k];
@@ -4695 +4689 @@
           break;
         }
       }
-    }
+        }
+  )
   
   /* During the owl reading, stones farther away may become parts of
    * the boundary. We mark those strings neighboring some other
    * friendly dragon with boundary value 2 right away, since we have
    * no mechanism for detecting this later.
    */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+  scan_board(pos,
     if (board[pos] == other && owl->boundary[pos] == 0) {
       /* If a lunch has been amalgamated into a larger dragon, we
        * have to back out now.
@@ -4729 +4724 @@
           break;
         }
       }
-    }
+        }
+  )
 }
 
 /* Add the stone just played to the goal dragon if same_dragon is
@@ -4981 +4977 @@
     /* Now put each goal string to the component to which it has the
      * smallest distance.
      */
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+    scan_board(pos,
       int closest_dist = HUGE_CONNECTION_DISTANCE;
       int closest_component = -1;
       if (board[pos] != color || !goal[pos])
@@ -4999 +4995 @@
         mark_string(pos, component2, closest_component);
         component_size[closest_component] += countstones(pos);
       }
-    }
+        )
 
     /* Now find the biggest_component. */
     {
@@ -5013 +5009 @@
     }
 
     /* Now delete everything except the biggest component from the goal. */
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+    scan_board(pos,
       if (component2[pos] != biggest_component)
-        goal[pos] = 0;
+            goal[pos] = 0;
+        )
+
     if (debug & DEBUG_SPLIT_OWL) {
       gprintf("Split dragon. Biggest component is %d (of %d).\n",
               biggest_component, num_components);
@@ -5065 +5063 @@
 goaldump(const signed char goal[BOARDMAX])
 {
   int pos;
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-    if (ON_BOARD(pos) && goal[pos])
+  scan_board(pos,
+    if (goal[pos])
       gprintf("%o%1m (%d)  ", pos, (int) goal[pos]);
+  )
   gprintf("\n");
 }
 
@@ -5075 +5074 @@
 componentdump(const signed char component[BOARDMAX])
 {
   int pos;
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-    if (ON_BOARD(pos) && component[pos] != -1)
+  scan_board(pos,
+    if (component[pos] != -1)
       gprintf("%o%1m (%d)  ", pos, (int) component[pos]);
+  )
   gprintf("\n");
 }
 
@@ -5133 +5133 @@
 {
   int pos;
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (!IS_STONE(board[pos])
         || dragon[pos].origin != pos)
       continue;
@@ -5316 +5316 @@
             "owl: %1m might defend the uncertain dragon at %1m at move %d\n",
             DRAGON2(pos).owl_attack_point, pos, movenum+1);
     }
-  }
+  )
 }
 
 /* Use the owl code to determine whether the move at (move) makes
@@ -5732 +5732 @@
   memset(owl->inessential, 0, sizeof(owl->inessential));
   
   memset(already_checked, 0, sizeof(already_checked));
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (board[pos] == color && owl->goal[pos]) {
       /* Loop over the eight neighbors. */
       for (k = 0; k < 8; k++) {
@@ -5870 +5870 @@
         }
       }
     }
-  }
+  )
 
   owl->lunches_are_current = 1;
   sgf_dumptree = save_sgf_dumptree;
@@ -6448 +6448 @@
 select_new_goal_origin(int origin, struct local_owl_data *owl)
 {
   int pos;
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+  scan_board(pos,
     if (board[pos] == owl->color && owl->goal[pos] == 1)
       return find_origin(pos);
+  )
 
   return origin;
 }
@@ -6527 +6528 @@
               compute_escape_influence(owl->color, safe_stones, owl->goal, NULL,
                                        escape_values);
 
-              for (pos2 = BOARDMIN; pos2 < BOARDMAX; pos2++) {
-                if (ON_BOARD(pos2))
-                  dragon[pos2] = is_same_dragon(pos2, pos);
-              }
+              scan_board(pos2,
+                    dragon[pos2] = is_same_dragon(pos2, pos);
+                  )
 
               if (dragon_escape(dragon, owl->color, escape_values) > 5)
                 owl->escape_values[pos] = 4;
@@ -6731 +6731 @@
   signed char modified_escape[BOARDMAX];
   int pos;
   memcpy(modified_escape, owl->escape_values, sizeof(modified_escape));
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-    if (ON_BOARD(pos) && owl->cumulative_goal[pos])
+  scan_board(pos,
+    if (owl->cumulative_goal[pos])
       modified_escape[pos] = 0;
+  )
   return dragon_escape(owl->goal, owl->color, modified_escape);
 }
 
@@ -6863 +6864 @@
   for (k = 0; k < MAX_GOAL_WORMS; k++)
     goal_worm[k] = NO_MOVE;
 
-  for (pos = BOARDMIN; pos < BOARDMAX && w < MAX_GOAL_WORMS; pos++) {
-    if (ON_BOARD(pos)
-        && board[pos]
+  scan_board(pos,
+    if (w >= MAX_GOAL_WORMS)
+          break;
+    if (board[pos]
         && owl->goal[pos] == 1) {
       int origin = find_origin(pos);
       for (k = 0; k < w; k++)
@@ -6874 +6876 @@
       if (k == w)
         goal_worm[w++] = pos;
     }
-  }
+  )
 
   /* experimental: let's try to fill up the array with other neighboring
    * opponent worms
@@ -6887 +6889 @@
       if (DRAGON(d).color != owl->color)
         continue;
 
-      for (ii = BOARDMIN; ii < BOARDMAX && w < MAX_GOAL_WORMS; ii++)
-        if (ON_BOARD(ii) && board[ii] && worm[ii].origin == ii
+          scan_board(ii,
+            if (w >= MAX_GOAL_WORMS)
+                  break;
+            if (board[ii] && worm[ii].origin == ii
             && worm[ii].size >= 3 && dragon[ii].id == d)
-          goal_worm[w++] = ii;
-    }
+              goal_worm[w++] = ii;
+          )
+        }
   }
 
   return w;
@@ -6946 +6951 @@
   for (k = 0; k < MAX_WORMS; k++)
     goal_worm[k] = NO_MOVE;
 
-  for (pos = BOARDMIN; pos < BOARDMAX && worms < MAX_WORMS; pos++)
-    if (ON_BOARD(pos)
-        && board[pos]
+  scan_board(pos,
+    if (worms >= MAX_WORMS)
+      break;
+    if (board[pos]
         && (owl->goal)[pos]) {
       int origin = find_origin(pos);
       if (pos == origin) {
@@ -6957 +6963 @@
         }
         goal_worm[worms++] = pos;
       }
-    }
+        }
+  )
   return worms;
 }
 #endif