Ticket #145: dragon.c.patch

gnugo/engine/dragon.c

@@ -144 +144 @@
     compute_dragon_genus(dragon2[d].origin, &dragon2[d].genus, NO_MOVE);
 
   /* Compute the escape route measure. */
-  for (str = BOARDMIN; str < BOARDMAX; str++)
+  scan_board(str,
     if (IS_STONE(board[str]) && dragon[str].origin == str)
       DRAGON2(str).escape_route = compute_escape(str, 0);
+  )
 
   /* Set dragon weaknesses according to initial_influence. */
   compute_refined_dragon_weaknesses();
@@ -154 +155 @@
     dragon2[d].weakness_pre_owl = dragon2[d].weakness;
 
   /* Determine status: ALIVE, DEAD, CRITICAL or UNKNOWN */
-  for (str = BOARDMIN; str < BOARDMAX; str++)
-    if (ON_BOARD(str))
-      if (dragon[str].origin == str && board[str])
-        dragon[str].crude_status = compute_crude_status(str);
+  scan_board(str,
+    if (dragon[str].origin == str && board[str])
+          dragon[str].crude_status = compute_crude_status(str);
+  )
   
   /* We must update the dragon status at every intersection before we
    * call the owl code. This updates all fields.
    */
-  for (str = BOARDMIN; str < BOARDMAX; str++)
-    if (ON_BOARD(str) && board[str] != EMPTY)
+  scan_board(str,
+    if (board[str] != EMPTY)
       dragon[str] = dragon[dragon[str].origin];
+  )
   
   find_neighbor_dragons();
 
@@ -191 +193 @@
    * if necessary.
    */
   start_timer(2);
-  for (str = BOARDMIN; str < BOARDMAX; str++)
-    if (ON_BOARD(str)) {
+  scan_board(str,
       int attack_point = NO_MOVE;
       int defense_point = NO_MOVE;
       struct eyevalue no_eyes;
@@ -287 +288 @@
           
         }
       }
-    }
+  )
   time_report(2, "  owl reading", NO_MOVE, 1.0);
   
   /* Compute the status to be used by the matcher. We most trust the
@@ -295 +296 @@
    * already confident that the dragon is alive, regardless of
    * crude_status.
    */
-  for (str = BOARDMIN; str < BOARDMAX; str++)
+  scan_board(str,
     if (IS_STONE(board[str])) {
       if (DRAGON2(str).owl_status != UNCHECKED)
         dragon[str].status = DRAGON2(str).owl_status;
       else
         dragon[str].status = ALIVE;
     }
+  )
 
   /* The dragon data is now correct at the origin of each dragon but
    * we need to copy it to every vertex.  
    */
-  for (str = BOARDMIN; str < BOARDMAX; str++)
-    if (ON_BOARD(str) && board[str] != EMPTY)
+  scan_board(str,
+    if (board[str] != EMPTY)
       dragon[str] = dragon[dragon[str].origin];
+  )
 
   identify_thrashing_dragons();
   
   /* Owl threats. */
-  for (str = BOARDMIN; str < BOARDMAX; str++)
-    if (ON_BOARD(str) 
-        && board[str] != EMPTY 
+  scan_board(str,
+    if (board[str] != EMPTY 
         && dragon[str].origin == str) {
       struct eyevalue no_eyes;
       set_eyevalue(&no_eyes, 0, 0, 0, 0);
@@ -330 +332 @@
       else {
         int acode = DRAGON2(str).owl_attack_code;
         int dcode = DRAGON2(str).owl_defense_code;
-        int defense_point, second_defense_point;
+        int defense_point;
+        int second_defense_point;
 
         if (get_level() >= 8
             && !disable_threat_computation
@@ -347 +350 @@
               DRAGON2(str).owl_threat_status = DEAD;
           }
           else if (!acode) {
-            int attack_point, second_attack_point;
+            int attack_point;
+                int second_attack_point;
             if (owl_threaten_attack(str, 
                                     &attack_point, &second_attack_point)) {
               DRAGON2(str).owl_threat_status = CAN_THREATEN_ATTACK;
@@ -359 +363 @@
           }
         }
       }
-    }
+        }
+  )
   
   /* Once again, the dragon data is now correct at the origin of each dragon
    * but we need to copy it to every vertex.  
    */
-  for (str = BOARDMIN; str < BOARDMAX; str++)
-    if (ON_BOARD(str) && board[str] != EMPTY)
+  scan_board(str,
+    if (board[str] != EMPTY)
       dragon[str] = dragon[dragon[str].origin];
+  )
 
   time_report(2, "  owl threats ", NO_MOVE, 1.0);
   
@@ -410 +416 @@
   /* The status is now correct at the origin of each dragon
    * but we need to copy it to every vertex.
    */
-  for (str = BOARDMIN; str < BOARDMAX; str++)
-    if (ON_BOARD(str))
-      dragon[str].status = dragon[dragon[str].origin].status;
+  scan_board(str,
+    dragon[str].status = dragon[dragon[str].origin].status;
+  )
 
   /* Revise inessentiality of critical worms and dragons. */
   revise_inessentiality();
@@ -438 +444 @@
 find_lunches()
 {
   int str;
-  for (str = BOARDMIN; str < BOARDMAX; str++)
-    if (ON_BOARD(str)) {
+  scan_board(str,
       int food;
 
       if (worm[str].origin != str
@@ -475 +480 @@
                 worm[food].origin, worm[food].cutstone);
         }
       }
-    }
+  )
 }
 
 
@@ -488 +493 @@
 { 
   int str;
 
-  for (str = BOARDMIN; str < BOARDMAX; str++) {
-    if (!ON_BOARD(str))
-      continue;
-
+  scan_board(str,
     if (black_eye[str].color == BLACK
         && black_eye[str].origin == str) {
       struct eyevalue value;
-      int attack_point, defense_point;
+      int attack_point;
+          int defense_point;
       
       compute_eyes(str, &value, &attack_point, &defense_point, 
                    black_eye, half_eye, 1);
@@ -508 +511 @@
     if (white_eye[str].color == WHITE
         && white_eye[str].origin == str) {
       struct eyevalue value;
-      int attack_point, defense_point;
+      int attack_point;
+          int defense_point;
       
       compute_eyes(str, &value, &attack_point, &defense_point,
                    white_eye, half_eye, 1);
@@ -517 +521 @@
       white_eye[str].value = value;
       propagate_eye(str, white_eye);
     }
-  }
+  )
 }
 
 
@@ -570 +574 @@
    * not dead, is considered inessential.
    */
 
-  for (str = BOARDMIN; str < BOARDMAX; str++)
-    if (ON_BOARD(str)) {
+  scan_board(str,
       if (is_worm_origin(str, str)
           && worm[str].attack_codes[0] != 0
           && worm[str].defense_codes[0] != 0
@@ -594 +597 @@
           propagate_worm(str);
         }
       }
-    }
+  )
 
   /* Revise essentiality of critical dragons. Specifically, a critical
    * dragon consisting entirely of inessential worms is considered
    * INESSENTIAL.
    */
-  for (str = BOARDMIN; str < BOARDMAX; str++) {
-    if (ON_BOARD(str)
-        && board[str] != EMPTY
+  scan_board(str,
+    if (board[str] != EMPTY
         && dragon[str].origin == str
         && DRAGON2(str).safety == CRITICAL) {
       int w;
@@ -617 +619 @@
         DRAGON2(str).safety = INESSENTIAL;
       }
     }
-  }
+  )
 }
 
 /* Initialize the dragon[] array. */
@@ -627 +629 @@
 {
   int str;
   /* VALGRIND_MAKE_WRITABLE(dragon, BOARDMAX * sizeof(struct dragon_data)); */
-  for (str = BOARDMIN; str < BOARDMAX; str++)
-    if (ON_BOARD(str)) {
-
+  scan_board(str,
       dragon[str].id                 = -1;
       dragon[str].size               = worm[str].size;
       dragon[str].effective_size     = worm[str].effective_size;
@@ -644 +644 @@
         DEBUG(DEBUG_DRAGONS, 
               "Initializing dragon from worm at %1m, size %d\n", 
               str, worm[str].size);
-    }
+  )
   memset(next_worm_list, 0, sizeof(next_worm_list));
 
   /* We need to reset this to avoid trouble on an empty board when
@@ -673 +673 @@
    * the dragon2 array. After this the DRAGON2 macro can be used.
    */
   number_of_dragons = 0;
-  for (str = BOARDMIN; str < BOARDMAX; str++) {
-    if (!ON_BOARD(str))
-      continue;
+  scan_board(str,
     origin = dragon[str].origin;
     
     if (board[str] == EMPTY)
@@ -684 +682 @@
     if (dragon[origin].id == -1)
       dragon[origin].id = number_of_dragons++;
     dragon[str].id = dragon[origin].id;
-  }
+  )
   
   /* Now number_of_dragons contains the number of dragons and we can
    * allocate a dragon2 array of the appropriate size. First throw
@@ -702 +700 @@
   /* Find the origins of the dragons to establish the mapping back to
    * the board. After this the DRAGON macro can be used.
    */
-  for (str = BOARDMIN; str < BOARDMAX; str++) {
-    if (!ON_BOARD(str))
-      continue;
+  scan_board(str,
     if (IS_STONE(board[str])
         && dragon[str].origin == str) {
       DRAGON2(str).origin = str;
     }
-  }
+  )
   
   /* Initialize the rest of the dragon2 data. */
   for (d = 0; d < number_of_dragons; d++) {
@@ -772 +768 @@
   gg_assert(dragon2_initialized);
   
   /* Initialize the arrays. */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (IS_STONE(board[pos])) {
       dragons[pos] = dragon[pos].id;
       distances[pos] = 0;
     }
-    else if (ON_BOARD(pos)) {
+    else {
       dragons[pos] = -1;
       distances[pos] = -1;
     }
-  }
+  )
 
   /* Expand from dist-1 to dist. Break out of the loop at the end if
    * we couldn't expand anything. Never expand more than five steps.
@@ -789 +785 @@
   for (dist = 1; dist <= 5; dist++) {
     int found_one = 0;
       
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-      if (!ON_BOARD(pos))
-        continue;
+    scan_board(pos,
     
       if (distances[pos] != dist-1 || dragons[pos] < 0)
         continue;
@@ -829 +823 @@
           }
         }
       }
-    }
+        )
     if (!found_one)
       break;
   }
@@ -855 +849 @@
    * where dragons==-2 we set all the neighbors of this intersection
    * as adjacent to each other.
    */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (!ON_BOARD(pos))
-      continue;
+  scan_board(pos,
     if (dragons[pos] == -2) {
       int neighbors = 0;
       int adjacent[4];
@@ -884 +876 @@
           add_adjacent_dragons(dragons[pos], dragons[EAST(pos)]);
       }
     }
-  }
+  )
   
   if (0) {
     for (d = 0; d < number_of_dragons; d++) {
@@ -957 +949 @@
   ASSERT1(IS_STONE(board[dr]), dr);
 
   /* First look for invincible strings in the dragon. */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (ON_BOARD(pos) && is_same_dragon(pos, dr) && worm[pos].invincible)
+  scan_board(pos,
+    if (is_same_dragon(pos, dr) && worm[pos].invincible)
       return 1;
-  }
+  )
 
   /* Can the dragon be owl attacked? */
   if (DRAGON2(dr).owl_status != UNCHECKED && DRAGON2(dr).owl_status != ALIVE)
@@ -978 +970 @@
 
   memset(mx, 0, sizeof(mx));
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     if (board[pos] == board[dr] && is_same_dragon(pos, dr)) {
       for (k = 0; k < 4; k++) {
         int pos2 = pos + delta[k];
@@ -997 +989 @@
         }
       }
     }
-  }
+  )
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     /* Necessary to check eye margins here since the loop above only
      * considers margins which are directly adjacent to some stone of
      * the dragon.
@@ -1007 +999 @@
     if (mx[pos] == 1
         && eye[pos].msize == 0)
       strong_eyes++;
-  }
+  )
 
   if (strong_eyes >= 2)
     return 1;
@@ -1117 +1109 @@
   
   for (dist = 1; dist < 5; dist++) {
     int pos;
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+    scan_board(pos,
       if (board[pos] != color
           || dragon[pos].origin != pos
           || thrashing_stone[pos] != dist)
@@ -1135 +1127 @@
                       (signed char)(dist + 1));
         }
       }
-    }
+        )
   }
 }
 
@@ -1144 +1136 @@
 set_dragon_strengths(const signed char safe_stones[BOARDMAX],
                      float strength[BOARDMAX])
 {
-  int ii;
-  for (ii = BOARDMIN; ii < BOARDMAX; ii++)
-    if (ON_BOARD(ii)) {
-      if (safe_stones[ii]) {
-        ASSERT1(IS_STONE(board[ii]), ii);
-        strength[ii] = DEFAULT_STRENGTH
-                       * (1.0 - 0.3 * DRAGON2(ii).weakness_pre_owl);
-      }
+  int pos;
+  scan_board(pos,
+      if (safe_stones[pos]) {
+        ASSERT1(IS_STONE(board[pos]), pos);
+        strength[pos] = DEFAULT_STRENGTH
+                       * (1.0 - 0.3 * DRAGON2(pos).weakness_pre_owl);
+          }
       else
-        strength[ii] = 0.0;
-    }
+        strength[pos] = 0.0;
+  )
 }
 
 /* Marks all inessential stones with INFLUENCE_SAFE_STONE, leaves
@@ -1163 +1154 @@
 void
 mark_inessential_stones(int color, signed char safe_stones[BOARDMAX])
 {
-  int ii;
-  for (ii = BOARDMIN; ii < BOARDMAX; ii++)
-    if (IS_STONE(board[ii])
-        && (DRAGON2(ii).safety == INESSENTIAL
-            || (worm[ii].inessential
+  int pos;
+  scan_board(pos,
+    if (IS_STONE(board[pos])
+        && (DRAGON2(pos).safety == INESSENTIAL
+            || (worm[pos].inessential
                 /* FIXME: Why is the check below needed?
                  * Why does it use .safety, not .status? /ab
                  */
-                && ((DRAGON2(ii).safety != DEAD
-                     && DRAGON2(ii).safety != TACTICALLY_DEAD
-                     && DRAGON2(ii).safety != CRITICAL)
-                    || (DRAGON2(ii).safety == CRITICAL
-                        && board[ii] == color)))))
-      safe_stones[ii] = INFLUENCE_SAFE_STONE;
+                && ((DRAGON2(pos).safety != DEAD
+                     && DRAGON2(pos).safety != TACTICALLY_DEAD
+                     && DRAGON2(pos).safety != CRITICAL)
+                    || (DRAGON2(pos).safety == CRITICAL
+                        && board[pos] == color)))))
+      safe_stones[pos] = INFLUENCE_SAFE_STONE;
+  )
 }
 
 void
@@ -1224 +1216 @@
   set_eyevalue(genus, 0, 0, 0, 0);
 
   if (board[d] == BLACK) {
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-      if (!ON_BOARD(pos))
-        continue;
+    scan_board(pos,
 
       if (black_eye[pos].color == BLACK
           && black_eye[pos].origin == pos
@@ -1244 +1234 @@
 
         add_eyevalues(genus, &black_eye[pos].value, genus);
       }
-    }
+        )
   }
   else {
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-      if (!ON_BOARD(pos))
-        continue;
+    scan_board(pos,
 
       if (white_eye[pos].color == WHITE
           && white_eye[pos].origin == pos
@@ -1267 +1255 @@
 
         add_eyevalues(genus, &white_eye[pos].value, genus);
       }
-    }
+        )
   }
 }
 
@@ -1307 +1295 @@
   struct eye_data *eye;
   int k;
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (!ON_BOARD(pos))
-      continue;
-    
+  scan_board(pos,
     false_eye_territory[pos] = 0;
 
     /* The analysis only applies to false and half eyes. */
@@ -1363 +1348 @@
       if (0)
         gprintf("False eye territory at %1m\n", pos);
     }
-  }
+  )
 
   /* FIXME: This initialization doesn't really belong here but must be
    *        done somewhere within examine_position().
    *        The array is eventually filled by the endgame() function.
    */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-    if (ON_BOARD(pos))
-      forced_backfilling_moves[pos] = 0;
+  scan_board(pos,
+    forced_backfilling_moves[pos] = 0;
+  )
 }
 
 /* 
@@ -1473 +1458 @@
   int pos;
   int k;
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     struct worm_data *w = &(worm[pos]);
     if (!IS_STONE(board[pos]))
       continue;
@@ -1539 +1524 @@
       if (is_ko_point(pos))
         gprintf("- is a ko stone\n");
     }
-  }
+  )
     
   gprintf("%o\n");
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     struct dragon_data *dd = &(dragon[pos]);
     struct dragon_data2 *d2;
     
@@ -1592 +1577 @@
       if (d2->lunch != NO_MOVE)
         gprintf("... adjacent worm %1m is lunch\n", d2->lunch);
     }
-  }
+  )
 }
 
 
@@ -1616 +1601 @@
   
   memcpy(saved_cutting_points, cutting_points, sizeof(cutting_points));
   memset(cutting_points, 0, sizeof(cutting_points));
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-    if (ON_BOARD(pos)) {
+  scan_board(pos,
       if (board[pos] == EMPTY)
         new_dragon_origins[pos] = NO_MOVE;
       else
         new_dragon_origins[pos] = find_origin(pos);
-    }
+  )
   
   find_cuts();
   find_connections();
@@ -1651 +1635 @@
   ASSERT1(IS_STONE(board[d1]), d1);
 
   /* Don't bother to do anything fancy with dragon origins. */
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-    if (ON_BOARD(pos) && new_dragon_origins[pos] == d2)
+  scan_board(pos,
+    if (new_dragon_origins[pos] == d2)
       new_dragon_origins[pos] = d1;
+  )
 }
 
 /* 
@@ -1717 +1702 @@
       next_worm_list[last_worm_origin_dragon] = d1;
   }
 
-  for (ii = BOARDMIN; ii < BOARDMAX; ii++) {
-    if (ON_BOARD(ii)
-        && (dragon[ii].origin == d1 || dragon[ii].origin == d2))
+  scan_board(ii,
+    if (dragon[ii].origin == d1 || dragon[ii].origin == d2)
       dragon[ii].origin = origin;
-  }
+  )
 }
 
 
@@ -1852 +1836 @@
   }
 
   /* Enter the stones of the dragon in the queue. */
-  for (ii = BOARDMIN; ii < BOARDMAX; ii++)
-    if (ON_BOARD(ii) && goal[ii])
+  scan_board(ii,
+    if (goal[ii])
       ENQUEUE(ii);
+  )
   
   /* Find points at increasing distances from the dragon. At distance
    * four, sum the escape values at those points to get the escape
@@ -1991 +1976 @@
 
   ASSERT1(IS_STONE(board[pos]), pos);
 
-  for (ii = BOARDMIN; ii < BOARDMAX; ii++)
-    if (ON_BOARD(ii))
-      goal[ii] = is_same_dragon(ii, pos);
+  scan_board(ii,
+    goal[ii] = is_same_dragon(ii, pos);
+  )
 
   /* Compute escape_value array.  Points are awarded for moyo (4),
    * area (2) or EMPTY (1).  Values may change without notice.
@@ -2002 +1987 @@
   compute_escape_influence(board[pos], safe_stones, NULL, 0, escape_value);
 
   /* If we can reach a live group, award 6 points. */
-  for (ii = BOARDMIN; ii < BOARDMAX; ii++) {
-    if (!ON_BOARD(ii))
-      continue;
+  scan_board(ii,
 
     if (dragon_status_known) {
       if (dragon[ii].crude_status == ALIVE)
@@ -2020 +2003 @@
           && worm[ii].attack_codes[0] == 0)
         escape_value[ii] = 2;
     }
-  }
+  )
   
   return dragon_escape(goal, board[pos], escape_value);
 }
@@ -2051 +2034 @@
   float moyo_values[BOARDMAX];
     
 
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+  scan_board(pos,
     moyo_sizes[pos] = 0.0;
     moyo_values[pos] = 0.0;
-  }
+  )
   
-  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
-    if (!ON_BOARD(pos))
-      continue;
+  scan_board(pos,
     moyo_color = whose_moyo_restricted(q, pos);
     
     if (moyo_color == board[pos])