Ticket #97: new_amalgamation_7_9.1.diff

engine/dragon.c

@@ -49 +49 @@
 
 #include "liberty.h"
 #include "gg_utils.h"
+#include "readconnect.h"
 
 static void initialize_supplementary_dragon_data(void);
+static void amalgamate_dragons(int color);
+static void build_dragon(int w, int amalgamated[BOARDMAX],
+                         float effective_sizes[BOARDMAX]);
 static void find_lunches(void);
 static void eye_computations(void);
 static void revise_inessentiality(void);
@@ -113 +117 @@
    * involved dragons.
    */
   memset(cutting_points, 0, sizeof(cutting_points));
+  if (experimental_connections)
+    initialize_static_worm_connections();
   find_cuts();
   find_connections();
+  if (experimental_connections) {
+    analyze_worm_connections();
+    amalgamate_dragons(BLACK);
+    amalgamate_dragons(WHITE);
+  }
 
   /* At this time, all dragons have been finalized and we can
    * initialize the dragon2[] array. After that we can no longer allow
@@ -744 +755 @@
 }
  
 
+static void
+amalgamate_dragons(int color)
+{
+  int amalgamated[BOARDMAX];
+  int pos;
+  float effective_sizes[BOARDMAX];
+
+  if (stackp == 0) {
+    for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+      if (IS_STONE(board[pos]))
+        effective_sizes[pos] = worm[pos].effective_size;
+  }
+  else {
+    compute_effective_string_sizes(effective_sizes);
+    for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+      if (IS_STONE(board[pos]))
+        effective_sizes[pos] = effective_sizes[find_origin(pos)];
+  }
+
+  memset(amalgamated, 0, sizeof(amalgamated));
+  while (1) {
+    int biggest_remaining_string = NO_MOVE;
+    float biggest_remaining_string_size = 0.0;
+    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+      if (board[pos] == color
+          && find_origin(pos) == pos
+          && !amalgamated[pos]
+          && effective_sizes[pos] > biggest_remaining_string_size) {
+        biggest_remaining_string = pos;
+        biggest_remaining_string_size = effective_sizes[pos];
+      }
+    }
+    if (biggest_remaining_string == NO_MOVE)
+      break;
+
+    build_dragon(biggest_remaining_string, amalgamated, effective_sizes);
+  }
+}
+
+static void
+build_dragon(int starting_worm, int amalgamated[BOARDMAX],
+             float effective_sizes[BOARDMAX])
+{
+  int color = board[starting_worm];
+  int worms_in_this_dragon[BOARDMAX];
+  int num_worms;
+  int aspiring_worms[BOARDMAX];
+  int num_aspiring;
+  int considered[BOARDMAX];
+  int k;
+  int pos;
+
+  DEBUG(DEBUG_DRAGONS, "Build dragon starting at %1m.\n", starting_worm);
+  
+  amalgamated[starting_worm] = 1;
+  worms_in_this_dragon[0] = starting_worm;
+  num_worms = 1;
+  num_aspiring = 0;
+  memset(considered, 0, sizeof(considered));
+
+  for (k = 0; k < num_worms; k++) {
+    int this_worm = worms_in_this_dragon[k];
+    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+      if (board[pos] != color || find_origin(pos) != pos
+          || amalgamated[pos] || considered[pos]
+          || !worms_are_connected(this_worm, pos))
+        continue;
+
+      DEBUG(DEBUG_DRAGONS, "  queueing %1m.\n", pos);
+      considered[pos] = 1;
+      aspiring_worms[num_aspiring] = pos;
+      num_aspiring++;
+    }
+    
+    while (num_aspiring > 0) {
+      int j;
+      int w;
+      int largest_worm = -1;
+      float largest_size = 0.0;
+      
+      for (j = 0; j < num_aspiring; j++) {
+        if (effective_sizes[aspiring_worms[j]] > largest_size) {
+          largest_worm = j;
+          largest_size = effective_sizes[aspiring_worms[j]];
+        }
+      }
+
+      w = aspiring_worms[largest_worm];
+      num_aspiring--;
+      aspiring_worms[largest_worm] = aspiring_worms[num_aspiring];
+      
+      for (j = 0; j < num_worms; j++) {
+        if (worms_are_intransitively_connected(w, worms_in_this_dragon[j])) {
+          DEBUG(DEBUG_DRAGONS,
+                "  intransitive connection to %1m, discarding %1m.\n",
+                worms_in_this_dragon[j], w);
+          break;
+        }
+      }
+      
+      if (j == num_worms) {
+        worms_in_this_dragon[num_worms] = w;
+        num_worms++;
+        amalgamated[w] = 1;
+        join_dragons(starting_worm, w);
+        break;
+      }
+    }
+  }
+}
+
 /* Examine which dragons are adjacent to each other. This is
  * complicated by the fact that adjacency may involve a certain
  * amount of empty space.
@@ -1601 +1723 @@
   int pos;
   int saved_cutting_points[BOARDMAX];
 
-  /* This is currently necessary in order not to mess up the
-   * worm[].cutstone2 field. See cutstone2_helper in
-   * patterns/helpers.c. On the other hand it shouldn't be very
+  /* This is currently necessary in order not to mess up various
+   * information such as the worm[].cutstone2 field (see
+   * cutstone2_helper in patterns/helpers.c) and the static worm
+   * connection analysis. On the other hand it shouldn't be very
    * interesting to recompute dragons in the original position.
    */
   gg_assert(stackp > 0);
@@ -1618 +1741 @@
         new_dragon_origins[pos] = find_origin(pos);
     }
   
+  if (experimental_connections)
+    initialize_static_worm_connections();
   find_cuts();
   find_connections();
+  if (experimental_connections) {
+    analyze_worm_connections();
+    amalgamate_dragons(BLACK);
+    amalgamate_dragons(WHITE);
+  }
 
   memcpy(cutting_points, saved_cutting_points, sizeof(cutting_points));
   memcpy(dragon_origins, new_dragon_origins, sizeof(new_dragon_origins));

engine/liberty.h

@@ -325 +325 @@
 void mark_inessential_stones(int color, signed char safe_stones[BOARDMAX]);
 
 void get_lively_stones(int color, signed char safe_stones[BOARDMAX]);
+void compute_effective_string_sizes(float effective_sizes[BOARDMAX]);
 int is_same_worm(int w1, int w2);
 int is_worm_origin(int w, int pos);
 void propagate_worm(int pos);
 void find_cuts(void);
 void find_connections(void);
 
+void initialize_static_worm_connections(void);
+void analyze_worm_connections(void);
+void register_potential_worm_connection(int w1, int w2);
+int worms_are_connected(int w1, int w2);
+int worms_are_connected_with_ko(int w1, int w2);
+int worms_are_close(int w1, int w2);
+int worms_are_intransitively_connected(int w1, int w2);
+
 /* movelist.c */
 int movelist_move_known(int move, int max_points, int points[], int codes[]);
 void movelist_change_point(int move, int code, int max_points, 

engine/owl.c

@@ -72 +72 @@
   /* Same as goal, except never anything is removed from it. */
   signed char cumulative_goal[BOARDMAX];
 
+  int original_goal_strings[MAX_GOAL_WORMS];
+  int num_original_goal_strings;
+  
   /* FIXME: neighbors[] and escape_values[] are never recomputed.
    *        Consider moving these arrays from stack to a static or
    *        dynamic variable so it is not copied around in
@@ -1839 +1842 @@
   int value1;
   int value2;
   int this_variation_number = count_variations - 1;
+  int all_original_strings_tactically_unstable;
+  SGFTree *save_sgf_dumptree;
+  int save_count_variations;
   
   SETUP_TRACE_INFO("owl_attack", str);
 
@@ -1880 +1886 @@
     READ_RETURN(OWL_ATTACK, str, depth - stackp, move, 0, 0);
   }
 
+  /* Do not give up if all original strings are tactically unstable.
+   */
+  save_sgf_dumptree = sgf_dumptree;
+  save_count_variations = count_variations;
+  sgf_dumptree = NULL;
+  count_variations = 0;
+  all_original_strings_tactically_unstable = 1;
+  for (k = 0; k < owl->num_original_goal_strings; k++) {
+    if (!attack(owl->original_goal_strings[k], NULL)) {
+      all_original_strings_tactically_unstable = 0;
+      break;
+    }
+  }
+  sgf_dumptree = save_sgf_dumptree;
+  count_variations = save_count_variations;
+  
   memset(mw, 0, sizeof(mw));
   global_owl_node_counter++;
   local_owl_node_counter++;
@@ -1889 +1911 @@
 
   /* First see whether there is any chance to kill. */
   if (owl_estimate_life(owl, NULL, vital_moves, &live_reason, 1,
-                        &probable_eyes, &eyemin, &eyemax)) {
+                        &probable_eyes, &eyemin, &eyemax)
+      && !all_original_strings_tactically_unstable) {
     /*
      * We need to check here if there's a worm under atari. If yes,
      * locate it and report a (gote) GAIN.
@@ -1931 +1954 @@
 
   /* We try moves in five passes.
    *                                stackp==0   stackp>0
-   * 0. Vital moves in the interval  [70..]      [45..]
-   * 1. Shape moves
-   * 2. Vital moves in the interval  [..69]      [..44]
-   * 3. Tactical attack moves (except certain kos)
-   * 4. Moves found by the defender
-   * 5. Tactical ko attack moves which were not tried in pass 3
+   * 1. Tactical attack moves if all original strings are unstable.
+   * 2. Vital moves in the interval  [70..]      [45..]
+   * 3. Shape moves
+   * 4. Vital moves in the interval  [..69]      [..44]
+   * 5. Tactical attack moves (except certain kos)
+   * 6. Moves found by the defender
+   * 7. Tactical ko attack moves which were not tried in pass 3
    */
-  for (pass = 0; pass < 6; pass++) {
+  for (pass = 1; pass < 8; pass++) {
     moves = NULL;
     move_cutoff = 1;
     
     current_owl_data = owl;
     /* Get the shape moves if we are in the right pass. */
     switch (pass) {
-    case 1:
+    case 3:
       if (stackp > owl_branch_depth && number_tried_moves > 0)
         continue;
       
@@ -1953 +1977 @@
       moves = shape_moves;
       break;
 
-    case 0:
     case 2:
+    case 4:
       if (stackp > owl_branch_depth && number_tried_moves > 0)
         continue;
       
       moves = vital_moves;
-      if (pass == 0 || stackp > owl_distrust_depth) {
+      if (pass == 2 || stackp > owl_distrust_depth) {
         if (stackp == 0)
           move_cutoff = 70;
         else
@@ -1969 +1993 @@
         move_cutoff = 99; /* Effectively disable vital moves. */
       break;
 
-    case 3:
+    case 1:
+      if (!all_original_strings_tactically_unstable)
+        break;
+      /* Otherwise fall through. */
     case 5:
+    case 7:
       {
         /* Look for a tactical attack. This is primarily intended for
          * the case where the whole dragon is a single string, therefore
@@ -1979 +2007 @@
          * We must be wary with attacks giving ko. Unless the dragon
          * otherwise looks alive, this may turn a dead dragon into one
          * which can live by ko. Such moves will be tried anyway in
-         * pass 5. Notice though that we can only reach there if an owl
-         * defense was found in pass 4.
+         * pass 7. Notice though that we can only reach there if an owl
+         * defense was found in pass 6.
          */
         int apos;
         int result;
@@ -1992 +2020 @@
         result = attack(str, &apos);
         if (result == WIN
             || (result != 0 && (min_eyes(&probable_eyes) >= 2
-                                || pass == 5))) {
+                                || pass == 7))) {
           set_single_owl_move(shape_moves, apos, "tactical attack");
           moves = shape_moves;
         }
@@ -2004 +2032 @@
     /* If we found no move in the first four passes we ask the defender
      * for a move suggestion.
      */
-    case 4:
+    case 6:
       if (number_tried_moves == 0) {
         int dpos;
         int dcode = do_owl_defend(str, &dpos, NULL, owl, escape);
@@ -2091 +2119 @@
       current_owl_data = owl;
 
       /* Shape moves are selected on demand. */
-      if (pass == 1) {
+      if (pass == 3) {
         if (!get_next_move_from_list(&shape_patterns, other,
                                      shape_moves, move_cutoff, owl))
           break;
@@ -2134 +2162 @@
        */
       if (IS_STONE(board[str]))
         origin = str;
+      else if (owl->num_original_goal_strings > 0)
+        origin = owl->original_goal_strings[0];
       else
-        origin = select_new_goal_origin(NO_MOVE, owl);
+        origin = NO_MOVE;
 
       /* Test whether the move cut the goal dragon apart. */
       if (moves[k].cuts[0] != NO_MOVE) {
@@ -2147 +2177 @@
 
       if (origin == NO_MOVE)
         dcode = 0;
-      else
+      else {
         dcode = do_owl_defend(origin, NULL, &wid, owl, escape);
+      }
 
       if (!ko_move) {
         if (dcode == 0) {
@@ -2473 +2504 @@
   int eyemin = -1;               /* Lower bound on the number of eyes. */
   int eyemax = -1;               /* Upper bound on the number of eyes. */
   struct eyevalue probable_eyes; /* Best guess of eyevalue. */
-  int escape_route;
   const char *live_reason;
   int move_cutoff;
   int xpos;
   int value1;
   int value2;
   int this_variation_number = count_variations - 1;
+  int all_original_strings_tactically_unstable;
+  SGFTree *save_sgf_dumptree;
+  int save_count_variations;
 
   SETUP_TRACE_INFO("owl_defend", str);
 
@@ -2514 +2547 @@
     return value1;
   }
 
+  /* Do not declare victory if all original strings are tactically
+   * unstable.
+   */
+  save_sgf_dumptree = sgf_dumptree;
+  save_count_variations = count_variations;
+  sgf_dumptree = NULL;
+  count_variations = 0;
+  all_original_strings_tactically_unstable = 1;
+  for (k = 0; k < owl->num_original_goal_strings; k++) {
+    if (!attack(owl->original_goal_strings[k], NULL)) {
+      all_original_strings_tactically_unstable = 0;
+      break;
+    }
+  }
+  sgf_dumptree = save_sgf_dumptree;
+  count_variations = save_count_variations;
+  
   /* In order to get a defense move even if we seem to already have
    * escaped and to reduce the impact of overestimated escape
    * possibilities, we don't declare escape victory on the first move.
@@ -2521 +2571 @@
    * FIXME: Should introduce a new owl depth value rather than having
    *        this hardwired value.
    */
-  escape_route = owl_escape_route(owl);
-  if (stackp > 2 && escape_route >= 5) {
-    /* FIXME: We probably should make distinction in the returned
-     * result whether the dragon lives by making two eyes or by
-     * escaping.
-     */
-    TRACE("%oVariation %d: ALIVE (escaped)\n", this_variation_number);
-    SGFTRACE(0, WIN, "escaped");
-    READ_RETURN(OWL_DEFEND, str, depth - stackp, move, 0, WIN);
+  if (stackp > 2 && !all_original_strings_tactically_unstable) {
+    int escape_route = owl_escape_route(owl);
+    if (escape_route >= 5) {
+      /* FIXME: We probably should make distinction in the returned
+       * result whether the dragon lives by making two eyes or by
+       * escaping.
+       */
+      TRACE("%oVariation %d: ALIVE (escaped)\n", this_variation_number);
+      SGFTRACE(0, WIN, "escaped");
+      READ_RETURN(OWL_DEFEND, str, depth - stackp, move, 0, WIN);
+    }
   }
 
-  /* If reading goes to deep or we run out of nodes, we assume life. */
+  /* If reading goes too deep or we run out of nodes, we assume life. */
   if (reading_limit_reached(&live_reason, this_variation_number)) {
     SGFTRACE(0, WIN, live_reason);
     READ_RETURN(OWL_DEFEND, str, depth - stackp, move, 0, WIN);
@@ -2545 +2597 @@
   current_owl_data = owl;
   memset(owl->safe_move_cache, 0, sizeof(owl->safe_move_cache));
 
-  /* First see whether we might already be alife. */
+  /* First see whether we might already be alive. */
   if (escape < MAX_ESCAPE) {
     if (owl_estimate_life(owl, NULL, vital_moves, &live_reason, 0,
-                          &probable_eyes, &eyemin, &eyemax)) {
+                          &probable_eyes, &eyemin, &eyemax)
+        && !all_original_strings_tactically_unstable) {
       SGFTRACE(0, WIN, live_reason);
       TRACE("%oVariation %d: ALIVE (%s)\n",
             this_variation_number, live_reason);
@@ -2571 +2624 @@
 
   /* We try moves in four passes.
    *                                stackp==0   stackp>0
-   * 0. Vital moves in the interval  [70..]      [45..]
-   * 1. Shape moves
-   * 2. Vital moves in the interval  [..69]      [..44]
-   * 3. Tactical defense moves
+   * 1. Tactical defense moves if all original strings unstable
+   * 2. Vital moves in the interval  [70..]      [45..]
+   * 3. Shape moves
+   * 4. Vital moves in the interval  [..69]      [..44]
+   * 5. Tactical defense moves
    */
-  for (pass = 0; pass < 4; pass++) {
+  for (pass = 1; pass < 6; pass++) {
     moves = NULL;
     move_cutoff = 1;
     
     current_owl_data = owl;
     switch (pass) {
     /* Get the shape moves if we are in the right pass. */
-    case 1:
+    case 3:
       
       if (stackp > owl_branch_depth && number_tried_moves > 0)
         continue;
@@ -2592 +2646 @@
       moves = shape_moves;
       break;
 
-    case 0:
     case 2:
+    case 4:
       if (stackp > owl_branch_depth && number_tried_moves > 0)
         continue;
       
       moves = vital_moves;
-      if (pass == 0 || stackp > owl_distrust_depth) {
+      if (pass == 2 || stackp > owl_distrust_depth) {
         if (stackp == 0)
           move_cutoff = 70;
         else if (eyemin + min_eyes(&probable_eyes) > 3)
@@ -2612 +2666 @@
         move_cutoff = 99; /* Effectively disable vital moves. */
       break;
 
-    case 3:
+    case 1:
+    case 5:
       {
         int goalcount = 0;
 
@@ -2622 +2677 @@
           if (ON_BOARD(k))
             goalcount += owl->goal[k];
 
-        if (goalcount < 5) {
+        if ((pass == 5 && all_original_strings_tactically_unstable)
+            || (pass == 5 && goalcount < 5)) {
 
           /* Look for a tactical defense. This is primarily intended for
            * the case where the whole dragon is a single string, therefore
@@ -2635 +2691 @@
            * confusing the eye analysis.
            */
           int dpos;
-          SGFTree *save_sgf_dumptree = sgf_dumptree;
-          int save_count_variations = count_variations;
+          save_sgf_dumptree = sgf_dumptree;
+          save_count_variations = count_variations;
 
           sgf_dumptree = NULL;
           count_variations = 0;
@@ -2676 +2732 @@
       
       current_owl_data = owl;
       
-      if (pass == 1) {
+      if (pass == 3) {
         if (!get_next_move_from_list(&shape_patterns, color, shape_moves,
                                      move_cutoff, owl))
           break;
@@ -4452 +4508 @@
   int color = board[apos];
   
   ASSERT1(bpos == NO_MOVE || board[bpos] == color, bpos);
-
+  
   if (new_dragons == NULL) {
     for (pos = BOARDMIN; pos < BOARDMAX; pos++)
       if (ON_BOARD(pos)) {
@@ -4474 +4530 @@
       }
   }
 
+  owl->num_original_goal_strings = 0;
+  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+    if (IS_STONE(board[pos])
+        && owl->goal[pos]
+        && owl->num_original_goal_strings < MAX_GOAL_WORMS
+        && find_origin(pos) == pos) {
+      owl->original_goal_strings[owl->num_original_goal_strings] = pos;
+      owl->num_original_goal_strings++;
+    }
+
   memcpy(owl->cumulative_goal, owl->goal, sizeof(owl->goal));
   owl->color = color;
   owl_mark_boundary(owl);
+  if (owl->num_original_goal_strings == 1)
+    owl_update_goal(apos, 2, NO_MOVE, owl, 0);
 }
 
 
@@ -4620 +4688 @@
   int stones[MAX_BOARD * MAX_BOARD];
   int num_stones;
   int k;
+  int m;
   int do_add = 1;
   SGFTree *save_sgf_dumptree = sgf_dumptree;
   int save_count_variations = count_variations;
@@ -4676 +4745 @@
       }
   }
 
+  /* Update the list of original goal strings. This move may have
+   * merged two or more of the strings.
+   */
+  for (k = 0; k < owl->num_original_goal_strings; k++) {
+    for (m = 0; m < k; m++)
+      if (same_string(owl->original_goal_strings[k],
+                      owl->original_goal_strings[m])) {
+        owl->num_original_goal_strings--;
+        owl->original_goal_strings[k] =
+          owl->original_goal_strings[owl->num_original_goal_strings];
+        k--;
+        break;
+      }
+  }
+
+  /*  It might also have recreated a previously captured string. */
+  if (owl->goal[pos] == 1
+      && owl->num_original_goal_strings < MAX_GOAL_WORMS) {
+    for (k = 0; k < owl->num_original_goal_strings; k++) {
+      if (same_string(owl->original_goal_strings[k], pos))
+        break;
+    }
+    if (k == owl->num_original_goal_strings) {
+      owl->original_goal_strings[owl->num_original_goal_strings] = pos;
+      owl->num_original_goal_strings++;
+    }
+  }
+
   if (1 && verbose)
     goaldump(owl->goal);
 }
@@ -4898 +4995 @@
   }
 
   mark_string(pos, owl->boundary, boundary_mark);
+
+  /* The move may have captured one or more of the original goal strings. */
+  for (k = 0; k < owl->num_original_goal_strings; k++) {
+    if (board[owl->original_goal_strings[k]] == EMPTY) {
+      owl->num_original_goal_strings--;
+      owl->original_goal_strings[k] =
+        owl->original_goal_strings[owl->num_original_goal_strings];
+      k--;
+    }
+  }
 }
 
 /* Lists the goal array. For use in GDB:
@@ -5964 +6071 @@
   int result;
   double start = 0.0;
   struct local_owl_data *owl;
+  int pos;
   int num_moves = 0;
 
   if (debug & DEBUG_OWL_PERFORMANCE)
@@ -6041 +6149 @@
   /* FIXME: We would want to use init_owl() here too, but it doesn't
    * fit very well with the construction of the goal array above.
    */
+  owl->num_original_goal_strings = 0;
+  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+    if (ON_BOARD(pos)
+        && owl->goal[pos]
+        && owl->num_original_goal_strings < MAX_GOAL_WORMS
+        && find_origin(pos) == pos) {
+      owl->original_goal_strings[owl->num_original_goal_strings] = pos;
+      owl->num_original_goal_strings++;
+    }
+
   memcpy(owl->cumulative_goal, owl->goal, BOARDMAX);
   compute_owl_escape_values(owl);
   owl_mark_boundary(owl);
@@ -6651 +6769 @@
   memcpy(new_owl->cumulative_goal, (*owl)->cumulative_goal,
          sizeof(new_owl->cumulative_goal));
   memcpy(new_owl->boundary, (*owl)->boundary, sizeof(new_owl->boundary));
+  memcpy(new_owl->original_goal_strings, (*owl)->original_goal_strings,
+         sizeof(new_owl->original_goal_strings));
+  new_owl->num_original_goal_strings = (*owl)->num_original_goal_strings;
   memcpy(new_owl->neighbors, (*owl)->neighbors, sizeof(new_owl->neighbors));
   memcpy(new_owl->escape_values, (*owl)->escape_values,
          sizeof(new_owl->escape_values));

engine/worm.c

@@ -32 +32 @@
 static void compute_effective_worm_sizes(void);
 static void do_compute_effective_worm_sizes(int color,
                                             int (*cw)[MAX_CLOSE_WORMS],
-                                            int *ncw, int max_distance);
+                                            int *ncw, float *effective_sizes,
+                                            int max_distance);
 static void compute_unconditional_status(void);
 static void find_worm_attacks_and_defenses(void);
 static void find_worm_threats(void);
@@ -566 +567 @@
 static void
 compute_effective_worm_sizes()
 {
+  float effective_sizes[BOARDMAX];
+  int pos;
+  
   do_compute_effective_worm_sizes(BLACK | WHITE, close_worms,
-                                  number_close_worms, 3);
+                                  number_close_worms, effective_sizes, 3);
+  
+  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+    if (IS_STONE(board[pos]))
+      worm[pos].effective_size = effective_sizes[worm[pos].origin];
+  
   do_compute_effective_worm_sizes(BLACK, close_black_worms,
-                                  number_close_black_worms, 5);
+                                  number_close_black_worms, NULL, 5);
+  
   do_compute_effective_worm_sizes(WHITE, close_white_worms,
-                                  number_close_white_worms, 5);
+                                  number_close_white_worms, NULL, 5);
+}
+
+/* Same as above but does not write to the worm array or update the
+ * close worms arrays. Intended to be used when stackp > 0.
+ */
+void
+compute_effective_string_sizes(float effective_sizes[BOARDMAX])
+{
+  do_compute_effective_worm_sizes(BLACK | WHITE, NULL, NULL,
+                                   effective_sizes, 3);
 }
 
 static void
 do_compute_effective_worm_sizes(int color, int (*cw)[MAX_CLOSE_WORMS],
-                                int *ncw, int max_distance)
+                                int *ncw, float *effective_sizes,
+                                int max_distance)
 {
   int pos;
 
@@ -647 +668 @@
     }
   }
 
-  /* Compute the effective sizes but only when all worms are considered. */
-  if (color == (BLACK | WHITE)) {
+  /* Compute the effective sizes if caller wants them. */
+  if (effective_sizes) {
+    for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+      if (ON_BOARD(pos))
+        effective_sizes[pos] = 0.0;
+      
     /* Distribute (fractional) contributions to the worms. */
     for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
       if (!ON_BOARD(pos))
@@ -657 +682 @@
       for (k = 0; k < nworms[pos]; k++) {
         int w = worms[pos][k];
         if (board[pos] == EMPTY)
-          worm[w].effective_size += 0.5/nworms[pos];
+          effective_sizes[w] += 0.5/nworms[pos];
         else
-          worm[w].effective_size += 1.0;
+          effective_sizes[w] += 1.0;
       }
     }
-    
-    /* Propagate the effective size values all over the worms. */
-    for (pos = BOARDMIN; pos < BOARDMAX; pos++)
-      if (IS_STONE(board[pos]) && is_worm_origin(pos, pos))
-        propagate_worm(pos);
   }
 
   /* Fill in the appropriate close_*_worms (cw) and
@@ -676 +696 @@
     if (!ON_BOARD(pos))
       continue;
 
-    if (nworms[pos] > MAX_CLOSE_WORMS)
-      ncw[pos] = 0;
-    else
-      ncw[pos] = nworms[pos];
+    if (ncw) {
+      if (nworms[pos] > MAX_CLOSE_WORMS)
+        ncw[pos] = 0;
+      else
+        ncw[pos] = nworms[pos];
+    }
 
-    for (k = 0; k < ncw[pos]; k++)
-      cw[pos][k] = worms[pos][k];
+    if (cw)
+      for (k = 0; k < ncw[pos]; k++) 
+        cw[pos][k] = worms[pos][k];
   }
 }
 
@@ -1621 +1644 @@
          * possible that it only has a ko defense and then we would
          * risk to find an irrelevant move to attack with ko.
          */
-        if (dcode != WIN && REVERSE_RESULT(dcode) >= worm[str].attack_codes[0]) {
+        if (dcode != WIN
+            && REVERSE_RESULT(dcode) >= worm[str].attack_codes[0]) {
           change_attack(str, move, REVERSE_RESULT(dcode));
           DEBUG(DEBUG_WORMS,
                 "Attack pattern %s+%d found attack on %1m at %1m with code %d\n",
@@ -1732 +1756 @@
 }
 
 /* ================================================================ */
+/*                Static worm connection analysis                   */
+/* ================================================================ */
+
+/* The static worm connection analysis uses the C patterns in conn.db
+ * to find worms which are close enough so that the connection reading
+ * can be expected to determine that they are expected unless there is
+ * a serious connection problem. Then connection reading is done to
+ * see which of these are indeed connected and intransitive
+ * connections (A connected to B and B connected to C but A not
+ * connected to C) are detected.
+ *
+ * The results are stored in a two-dimensional array for each pair of
+ * worms. Only the worm origins have valid data. Each entry is an
+ * unsigned char where the three lowest bits contain the disconnect
+ * result code, the fourth bit marks potential connections (as found
+ * by the C patterns in conn.db) and the fifth bit is set for pairs of
+ * strings being intransitively connected.
+ *
+ * There are two parallel worm connection matrices. The primary one is
+ * used at stackp==0 and contains the static information for the
+ * original position. The secondary array is used when stackp>0,
+ * primarily to allow computation of a new set of dragons after a move
+ * has been made.
+ */
+static unsigned char primary_worm_connection_matrix[BOARDMAX][BOARDMAX];
+static unsigned char secondary_worm_connection_matrix[BOARDMAX][BOARDMAX];
+/* The three lowest bits in the matrix store the disconnect result. */
+#define POTENTIAL_WORM_CONNECTION     8
+#define INTRANSITIVE_WORM_CONNECTION 16
+
+void
+initialize_static_worm_connections(void)
+{
+  int w1;
+  int w2;
+
+  unsigned char (*worm_connection_matrix)[BOARDMAX][BOARDMAX];
+  if (stackp == 0)
+    worm_connection_matrix = &primary_worm_connection_matrix;
+  else
+    worm_connection_matrix = &secondary_worm_connection_matrix;
+  
+#if 0
+  memset(worm_connection_matrix, 0, sizeof(worm_connection_matrix));
+#else
+  for (w1 = BOARDMIN; w1 < BOARDMAX; w1++)
+    for (w2 = BOARDMIN; w2 < BOARDMAX; w2++)
+      (*worm_connection_matrix)[w1][w2] = 0;
+#endif
+}
+
+#define DEBUG_EXPERIMENTAL_CONNECTIONS \
+  ((debug & DEBUG_DRAGONS) && experimental_connections)
+
+
+void
+analyze_worm_connections()
+{
+  int w1;
+  int w2;
+  int w3;
+
+  unsigned char (*worm_connection_matrix)[BOARDMAX][BOARDMAX];
+  if (stackp == 0)
+    worm_connection_matrix = &primary_worm_connection_matrix;
+  else
+    worm_connection_matrix = &secondary_worm_connection_matrix;
+  
+  if (DEBUG_EXPERIMENTAL_CONNECTIONS)
+    gprintf("analyze_worm_connections\n");
+  
+  for (w1 = BOARDMIN; w1 < BOARDMAX; w1++) {
+    if (!IS_STONE(board[w1]) || w1 != find_origin(w1))
+      continue;
+    
+    for (w2 = w1 + 1; w2 < BOARDMAX; w2++) {
+      if (board[w2] != board[w1] || w2 != find_origin(w2))
+        continue;
+
+      if ((*worm_connection_matrix)[w1][w2] & POTENTIAL_WORM_CONNECTION) {
+        int nodes = get_connection_node_counter();
+        unsigned char disconnect_result = disconnect(w1, w2, NULL);
+        gg_assert(disconnect_result < 8);
+        (*worm_connection_matrix)[w1][w2] |= disconnect_result;
+        (*worm_connection_matrix)[w2][w1] |= disconnect_result;
+        if (DEBUG_EXPERIMENTAL_CONNECTIONS)
+          gprintf("disconnect %1m %1m = %d, %d nodes %d %d\n", w1, w2,
+                  disconnect_result, get_connection_node_counter() - nodes,
+                  (*worm_connection_matrix)[w1][w2],
+                  (*worm_connection_matrix)[w2][w1]);
+      }
+    }
+  }
+
+  for (w1 = BOARDMIN; w1 < BOARDMAX; w1++) {
+    if (!IS_STONE(board[w1]) || w1 != find_origin(w1))
+      continue;
+    
+    for (w2 = BOARDMIN; w2 < BOARDMAX; w2++) {
+      if (w2 == w1 || board[w2] != board[w1] || w2 != find_origin(w2))
+        continue;
+
+      if (!((*worm_connection_matrix)[w1][w2] & POTENTIAL_WORM_CONNECTION)
+          || ((*worm_connection_matrix)[w1][w2] & 7) != 0)
+        continue;
+
+      for (w3 = BOARDMIN; w3 < BOARDMAX; w3++) {
+        if (w3 == w2 || board[w3] != board[w2] || w3 != find_origin(w3))
+          continue;
+      
+        if (!((*worm_connection_matrix)[w2][w3] & POTENTIAL_WORM_CONNECTION)
+            || ((*worm_connection_matrix)[w2][w3] & 7) != 0)
+          continue;
+
+        if (((*worm_connection_matrix)[w1][w3] & POTENTIAL_WORM_CONNECTION)
+            && ((*worm_connection_matrix)[w1][w3] & 7) != 0) {
+          if (DEBUG_EXPERIMENTAL_CONNECTIONS)
+            gprintf("intransitive connection %1m - %1m - %1m %d\n", w1, w2, w3,
+                    (*worm_connection_matrix)[w1][w3],
+                    (*worm_connection_matrix)[w3][w1]);
+          (*worm_connection_matrix)[w1][w3] |= INTRANSITIVE_WORM_CONNECTION;
+          (*worm_connection_matrix)[w3][w1] |= INTRANSITIVE_WORM_CONNECTION;
+        }
+      }
+    }
+  }
+}
+
+static void
+normalize_worms(int *w1, int *w2)
+{
+  *w1 = find_origin(*w1);
+  *w2 = find_origin(*w2);
+}
+
+void
+register_potential_worm_connection(int w1, int w2)
+{
+  unsigned char (*worm_connection_matrix)[BOARDMAX][BOARDMAX];
+  if (stackp == 0)
+    worm_connection_matrix = &primary_worm_connection_matrix;
+  else
+    worm_connection_matrix = &secondary_worm_connection_matrix;
+  
+  normalize_worms(&w1, &w2);
+  if (DEBUG_EXPERIMENTAL_CONNECTIONS
+      && !((*worm_connection_matrix)[w1][w2] & POTENTIAL_WORM_CONNECTION))
+    gprintf("Registered potential worm connection %1m - %1m %d %d\n", w1, w2,
+            (*worm_connection_matrix)[w1][w2],
+            (*worm_connection_matrix)[w2][w1]);
+  (*worm_connection_matrix)[w1][w2] |= POTENTIAL_WORM_CONNECTION;
+  (*worm_connection_matrix)[w2][w1] |= POTENTIAL_WORM_CONNECTION;
+}
+
+int
+worms_are_connected(int w1, int w2)
+{
+  unsigned char (*worm_connection_matrix)[BOARDMAX][BOARDMAX];
+  if (stackp == 0)
+    worm_connection_matrix = &primary_worm_connection_matrix;
+  else
+    worm_connection_matrix = &secondary_worm_connection_matrix;
+  
+  normalize_worms(&w1, &w2);
+  if (((*worm_connection_matrix)[w1][w2] & POTENTIAL_WORM_CONNECTION)
+      && ((*worm_connection_matrix)[w1][w2] & 7) == 0)
+    return 1;
+
+  return 0;
+}
+
+int
+worms_are_connected_with_ko(int w1, int w2)
+{
+  unsigned char (*worm_connection_matrix)[BOARDMAX][BOARDMAX];
+  if (stackp == 0)
+    worm_connection_matrix = &primary_worm_connection_matrix;
+  else
+    worm_connection_matrix = &secondary_worm_connection_matrix;
+  
+  normalize_worms(&w1, &w2);
+  if (((*worm_connection_matrix)[w1][w2] & POTENTIAL_WORM_CONNECTION)
+      && (((*worm_connection_matrix)[w1][w2] & 7) == KO_A
+          || ((*worm_connection_matrix)[w1][w2] & 7) == KO_B))
+    return 1;
+
+  return 0;
+}
+
+int
+worms_are_close(int w1, int w2)
+{
+  unsigned char (*worm_connection_matrix)[BOARDMAX][BOARDMAX];
+  if (stackp == 0)
+    worm_connection_matrix = &primary_worm_connection_matrix;
+  else
+    worm_connection_matrix = &secondary_worm_connection_matrix;
+  
+  normalize_worms(&w1, &w2);
+  return ((*worm_connection_matrix)[w1][w2] & POTENTIAL_WORM_CONNECTION);
+}
+
+int
+worms_are_intransitively_connected(int w1, int w2)
+{
+  unsigned char (*worm_connection_matrix)[BOARDMAX][BOARDMAX];
+  if (stackp == 0)
+    worm_connection_matrix = &primary_worm_connection_matrix;
+  else
+    worm_connection_matrix = &secondary_worm_connection_matrix;
+  
+  normalize_worms(&w1, &w2);
+  return ((*worm_connection_matrix)[w1][w2] & INTRANSITIVE_WORM_CONNECTION);
+}
+
+/* ================================================================ */
 /*                      Debugger functions                          */
 /* ================================================================ */
 

patterns/conn.db

@@ -77 +77 @@
 #
 ########################
 
-callback_data X!
+callback_data OX!
+
+Pattern EB1
+
+OxOxO
+..*..
+-----
+
+:|,BY
 
 
 ##########################
@@ -86 +94 @@
 #
 ##########################
 
-callback_data X!
+callback_data OX!
 
 
 Pattern CB1b
@@ -443 +451 @@
 #
 ############################
 
+Pattern CC330
+
+O.o
+XOo
+O.o
+XOo
+
+:8,CY
+
+
+
 ####################################################################
 #
 # CC4xx -  fragile double connections
@@ -489 +508 @@
 Xaf
 ?e.
 
-;xcut(a)
+;xcut(a) && !experimental_connections
 
 >if (!xplay_attack_either(b,c,d,b,d) || !xplay_attack_either(c,b,a,c,a))
 >  amalgamate(e,f);

patterns/connections.c

@@ -40 +40 @@
   int first_dragon  = NO_MOVE;
   int second_dragon = NO_MOVE;
 
+  /* Strings of our color. */
+  int o_strings[BOARDMAX];
+  int o_nstrings = 0;
+
   int other = OTHER_COLOR(color);
   UNUSED(data);
 
   move = AFFINE_TRANSFORM(pattern->move_offset, ll, anchor);
   
-  if ((pattern->class & CLASS_B) && !safe_move(move, other))
+  if ((pattern->class & CLASS_B) && !safe_move(move, other)
+      && !experimental_connections)
+    return;
+
+  if ((pattern->class & CLASS_Y) && !experimental_connections)
     return;
 
-  if (pattern->class & CLASS_C) {
+  if ((pattern->class & CLASS_C) || experimental_connections) {
     /* If C pattern, test if there are more than one dragon in this
      * pattern so that there is something to connect, before doing any
      * expensive reading.
@@ -57 +65 @@
     for (k = 0; k < pattern->patlen; ++k) { /* match each point */
       /* transform pattern real coordinate */
       int pos = AFFINE_TRANSFORM(pattern->patn[k].offset, ll, anchor);
-      
-      /* Look for distinct dragons. */
+
       if (pattern->patn[k].att == ATT_O) {
-        if (first_dragon == NO_MOVE)
-          first_dragon = dragon[pos].origin;
-        else if (second_dragon == NO_MOVE
-                 && dragon[pos].origin != first_dragon) {
-          second_dragon = dragon[pos].origin;
-          /* A second dragon found, no need to continue looping. */
-          break;
+        if (!experimental_connections) {
+          /* Look for distinct dragons. */
+          if (first_dragon == NO_MOVE)
+            first_dragon = dragon[pos].origin;
+          else if (second_dragon == NO_MOVE
+                   && dragon[pos].origin != first_dragon) {
+            second_dragon = dragon[pos].origin;
+            /* A second dragon found, no need to continue looping. */
+            break;
+          }
+        }
+        else {
+          int origin = find_origin(pos);
+          int l;
+          for (l = 0; l < o_nstrings; l++) {
+            if (o_strings[l] == origin)
+              break;
+          }
+          if (l == o_nstrings) {
+            for (l = 0; l < o_nstrings; l++)
+              register_potential_worm_connection(o_strings[l], origin);
+            o_strings[l] = origin;
+            o_nstrings++;
+          }
         }
       }
     }
-    if (second_dragon == NO_MOVE)
+    if (!experimental_connections && second_dragon == NO_MOVE)
       return; /* Nothing to amalgamate. */
   }
     
@@ -144 +168 @@
      * can be attacked.
      */
     if ((pattern->class & CLASS_C)
+        && !experimental_connections
         && board[pos] == color
         && pattern->patn[k].att == ATT_O
         && ((pattern->class & CLASS_s) || attack(pos, NULL) == 0)) {

patterns/helpers.c

@@ -428 +428 @@
 void
 amalgamate_most_valuable_helper(int apos, int bpos, int cpos)
 {
+  if (experimental_connections)
+    return;
   if (!is_same_dragon(apos, bpos) && !is_same_dragon(bpos, cpos)) {
     if (dragon[apos].effective_size >= dragon[cpos].effective_size)
       join_dragons(apos, bpos);

patterns/owl_defendpats.db

@@ -7074 +7074 @@
 ;&& oplay_disconnect(*,a,b) != WIN
 
 
+Pattern D1396
+# gf New pattern. (3.7.5)
+# See gifu03:404
+
+O...O
+.*.O.
+-----
+
+:8,b,value(80)
+
+B...A
+.*.O.
+-----
+
+;attack(A) && owl_strong_dragon(B) && !oplay_disconnect(*,A,B)
+
+
 #########################################################
 #                                                       #
 #                          Ko                           #

patterns/patterns2.db

@@ -852 +852 @@
 ;oplay_attack_either(*,a,B,a) && !oplay_attack(*,c) && !oplay_attack(*,d)
 
 
+Pattern Conn612
+
+O*O.
+XOXO
+
+:8,C
+
+
 ##############################################
 #
 # Connection of two space jump from two stones