Ticket #156: gunnar_7_11.4.diff

engine/owl.c

@@ -81 +81 @@
 
   signed char escape_values[BOARDMAX];
   int color;
+  int origin;
 
   struct eye_data my_eye[BOARDMAX];
   /* array of half-eye data for use during owl reading */
@@ -97 +98 @@
 
   signed char safe_move_cache[BOARDMAX];
 
+  int escape_moves; /* Number of escape moves. */
+  
   /* This is used to organize the owl stack. */
   struct local_owl_data *restore_from;
 };
@@ -172 +175 @@
 void dump_pattern_list(struct matched_patterns_list_data *list);
 
 
-static int do_owl_attack(int str, int *move, int *wormid,
-                         struct local_owl_data *owl, int escape);
-static int do_owl_defend(int str, int *move, int *wormid,
-                         struct local_owl_data *owl, int escape);
+static int owl_attack_trymove(int mpos, struct local_owl_data **owl,
+                              struct owl_move_data *move, int *ko_move,
+                              int savecode);
+static int owl_defend_trymove(int mpos, struct local_owl_data **owl,
+                              struct owl_move_data *move, int *ko_move,
+                              int savecode);
+static void owl_popgo(struct local_owl_data **owl);
+static int do_owl_attack(struct local_owl_data *owl, int *move, int *wormid);
+static int do_owl_defend(struct local_owl_data *owl, int *move, int *wormid);
 static void owl_shapes(struct matched_patterns_list_data *list,
                        struct owl_move_data moves[MAX_MOVES], int color,
                        struct local_owl_data *owl, struct pattern_db *type);
@@ -248 +256 @@
                         struct local_owl_data *owl);
 static void eat_lunch_escape_bonus(int lunch, int *min, int *probable,
                                    int *max, struct local_owl_data *owl);
-static int select_new_goal_origin(int origin, struct local_owl_data *owl);
+static int select_new_goal_origin(struct local_owl_data *owl);
 static void compute_owl_escape_values(struct local_owl_data *owl);
 static int owl_escape_route(struct local_owl_data *owl);
-static void do_owl_analyze_semeai(int apos, int bpos, 
-                                  struct local_owl_data *owla,
+static void do_owl_analyze_semeai(struct local_owl_data *owla,
                                   struct local_owl_data *owlb,
                                   int *resulta, int *resultb,
                                   int *move, int pass, int owl_phase);
-static int semeai_trymove_and_recurse(int apos, int bpos,
-                                      struct local_owl_data *owla,
+static int semeai_trymove_and_recurse(struct local_owl_data *owla,
                                       struct local_owl_data *owlb,
                                       int owl_phase,
                                       int move, int color, int ko_allowed,
@@ -519 +525 @@
   else {
     reduced_init_owl(&owla, 1);
     reduced_init_owl(&owlb, 0);
-    local_owl_node_counter = 0;
+    owla->origin = apos;
+    owlb->origin = bpos;
     owl_mark_worm(apos, NO_MOVE, owla);
     owl_mark_worm(bpos, NO_MOVE, owlb);
   }
@@ -569 +576 @@
     prefer_ko = EMPTY;
   
   if (move == PASS_MOVE)
-    do_owl_analyze_semeai(apos, bpos, owla, owlb,
-                          resulta, resultb, semeai_move, 0, owl);
+    do_owl_analyze_semeai(owla, owlb, resulta, resultb, semeai_move, 0, owl);
   else {
-    semeai_trymove_and_recurse(bpos, apos, owlb, owla, owl,
-                               move, color, 1, 0, "mandatory move",
+    semeai_trymove_and_recurse(owlb, owla, owl, move, color, 1, 0,
+                               "mandatory move",
                                SAME_DRAGON_MAYBE_CONNECTED, NULL, NO_MOVE,
                                semeai_move, resultb, resulta);
     *resulta = REVERSE_RESULT(*resulta);
@@ -619 +625 @@
  */
 
 static void
-do_owl_analyze_semeai(int apos, int bpos, 
-                      struct local_owl_data *owla,
+do_owl_analyze_semeai(struct local_owl_data *owla,
                       struct local_owl_data *owlb,
                       int *resulta, int *resultb,
                       int *move, int pass, int owl_phase)
 {
+  int apos = owla->origin;
+  int bpos = owlb->origin;
   int color = board[apos];
   int other = OTHER_COLOR(color);
 #if 0
@@ -1114 +1121 @@
     /* Try playing the move at mpos and call ourselves recursively to
      * determine the result obtained by this move.
      */
-    if (semeai_trymove_and_recurse(apos, bpos, owla, owlb,
-                                   owl_phase, mpos, color,
+    if (semeai_trymove_and_recurse(owla, owlb, owl_phase, mpos, color,
                                    best_resulta == 0 || best_resultb == 0,
                                    moves[k].value, moves[k].name,
                                    moves[k].same_dragon, moves[k].pattern_data,
@@ -1239 +1245 @@
     }
     else {
     /* No working move was found, but opponent hasn't passed. Then we pass. */
-      do_owl_analyze_semeai(bpos, apos, owlb, owla,
-                            resultb, resulta, NULL, 1, owl_phase);
+      do_owl_analyze_semeai(owlb, owla, resultb, resulta, NULL, 1, owl_phase);
       *resulta = REVERSE_RESULT(*resulta);
       *resultb = REVERSE_RESULT(*resultb);
       TRACE("No move found\n");
@@ -1266 +1271 @@
  * move.
  */
 static int
-semeai_trymove_and_recurse(int apos, int bpos, struct local_owl_data *owla,
+semeai_trymove_and_recurse(struct local_owl_data *owla,
                            struct local_owl_data *owlb,
                            int owl_phase,
                            int move, int color, int ko_allowed,
@@ -1276 +1281 @@
                            int lunch, int *semeai_move,
                            int *this_resulta, int *this_resultb)
 {
+  int apos = owla->origin;
+  int bpos = owlb->origin;
   int ko_move = 0;
   
   gg_assert(this_resulta != NULL && this_resultb != NULL);
@@ -1317 +1324 @@
     /* FIXME: Are all owl_data fields and relevant static
      * variables properly set up for a call to do_owl_attack()?
      */
-    *this_resulta = REVERSE_RESULT(do_owl_attack(apos, semeai_move, NULL, owla, 0));
+    *this_resulta = REVERSE_RESULT(do_owl_attack(owla, semeai_move, NULL));
     *this_resultb = *this_resulta;
   }
   else {
-    do_owl_analyze_semeai(bpos, apos, owlb, owla,
-                          this_resultb, this_resulta, semeai_move,
+    do_owl_analyze_semeai(owlb, owla, this_resultb, this_resulta, semeai_move,
                           0, owl_phase);
     *this_resulta = REVERSE_RESULT(*this_resulta);
     *this_resultb = REVERSE_RESULT(*this_resultb);
@@ -1754 +1760 @@
 }
 
 
-/* Returns true if a move can be found to attack the dragon
- * at (target), in which case (*attack_point) is the recommended move.
- * (attack_point) can be a null pointer if only the result is needed.
- *
- * The array goal marks the extent of the dragon. This must
- * be maintained during reading. Call this function only when
- * stackp==0; otherwise you can call do_owl_attack but you must
- * set up the goal and boundary arrays by hand first.
- *
- * Returns KO_A or KO_B if the position is ko:
- *
- * - Returns KO_A if the attack prevails provided attacker is willing to
- *   ignore any ko threat (the attacker makes the first ko capture).
- *
- * - Returns KO_B if attack succeeds provided attacker has a ko threat
- *   which must be answered (the defender makes the first ko capture).
- *
- * If GNU Go is compiled with `configure --enable-experimental-owl-ext'
- * then a return codes of GAIN is also possible.
- *
- * - Returns GAIN if the attack fails but another worm of the
- *   opponent's is captured in during the failed attack. The location
- *   of the killed worm is returned through the *kworm field.
- *
- * */
-
-int
-owl_attack(int target, int *attack_point, int *certain, int *kworm)
+/* Play an attacking move in owl reading.
+ * In addition to playing the move this involves pushing the owl data
+ * and then updating the owl information.
+ */
+static int
+owl_attack_trymove(int mpos, struct local_owl_data **owl,
+                   struct owl_move_data *move, int *ko_move, int savecode)
 {
-  int result;
-  struct local_owl_data *owl;
-  int reading_nodes_when_called = get_reading_node_counter();
-  double start = 0.0;
-  int tactical_nodes;
-  int move = NO_MOVE;
-  int wpos = NO_MOVE;
-  int wid = MAX_GOAL_WORMS;
-
-  result_certain = 1;
-  if (worm[target].unconditional_status == DEAD) {
-    if (attack_point)
-      *attack_point = NO_MOVE;
-    if (kworm)
-      *kworm = NO_MOVE;
-    if (certain)
-      *certain = 1;
-    return 1;
+  int other = OTHER_COLOR((*owl)->color);
+  /* Try to make the move. */
+  if (!komaster_trymove(mpos, other, move->name, (*owl)->origin,
+                        ko_move, savecode == 0))
+    return 0;
+  
+  /* We have now made a move. Analyze the new position. */
+  push_owl(owl);
+  
+  TRACE("Trying %C %1m. Escape = %d. Current stack: ",
+        other, mpos, (*owl)->escape_moves);
+  if (verbose)
+    dump_stack();
+  
+  owl_update_boundary_marks(mpos, *owl);
+  
+  /* If the origin of the dragon has been captured, we look
+   * for another string which was part of the original dragon,
+   * marked when stackp==0, which has not been captured. If no
+   * such string is found, owl_attack declares victory.
+   */
+  if (!IS_STONE(board[(*owl)->origin]))
+    (*owl)->origin = select_new_goal_origin(*owl);
+  
+  /* Test whether the move cut the goal dragon apart. */
+  if (move->cuts[0] != NO_MOVE && (*owl)->origin != NO_MOVE) {
+    owl_test_cuts((*owl)->goal, (*owl)->color, move->cuts);
+    if (!(*owl)->goal[(*owl)->origin])
+      (*owl)->origin = select_new_goal_origin(*owl);
   }
+  mark_goal_in_sgf((*owl)->goal);
 
-  if (search_persistent_owl_cache(OWL_ATTACK, target, 0, 0, &result,
-                                  attack_point, kworm, certain))
-    return result;
+  return 1;
+}
 
-  if (debug & DEBUG_OWL_PERFORMANCE)
-    start = gg_cputime();
+
+/* Play a defending move in owl reading.
+ * In addition to playing the move this involves pushing the owl data
+ * and then updating the owl information.
+ */
+static int
+owl_defend_trymove(int mpos, struct local_owl_data **owl,
+                   struct owl_move_data *move, int *ko_move, int savecode)
+{
+  /* Try to make the move. */
+  if (!komaster_trymove(mpos, (*owl)->color, move->name, (*owl)->origin,
+                        ko_move, savecode == 0))
+    return 0;
   
-  TRACE("owl_attack %1m\n", target);
-  init_owl(&owl, target, NO_MOVE, NO_MOVE, 1, NULL);
-  owl_make_domains(owl, NULL);
-  prepare_goal_list(target, owl, owl_goal_worm, &goal_worms_computed,
-                    kworm, 1);
-  result = do_owl_attack(target, &move, &wid, owl, 0);
-  finish_goal_list(&goal_worms_computed, &wpos, owl_goal_worm, wid);
-  tactical_nodes = get_reading_node_counter() - reading_nodes_when_called;
+  /* We have now made a move. Analyze the new position. */
+  push_owl(owl);
+  
+  TRACE("Trying %C %1m. Escape = %d. Current stack: ",
+        (*owl)->color, mpos, (*owl)->escape_moves);
+  if (verbose)
+    dump_stack();
+  
+  if (move->escape)
+    (*owl)->escape_moves++;
+  
+  /* Add the stone just played to the goal dragon, unless the
+   * pattern explicitly asked for not doing this.
+   */
+  owl_update_goal(mpos, move->same_dragon, move->lunch, *owl, 0,
+                  move->pattern_data);
+  mark_goal_in_sgf((*owl)->goal);
 
-  DEBUG(DEBUG_OWL_PERFORMANCE,
-    "owl_attack %1m, result %d %1m (%d, %d nodes, %f seconds)\n",
-    target, result, move, local_owl_node_counter,
-    tactical_nodes, gg_cputime() - start);
+  return 1;
+}
 
-  store_persistent_owl_cache(OWL_ATTACK, target, 0, 0,
-                             result, move, wpos,
-                             result_certain, tactical_nodes,
-                             owl->goal, board[target]);
-  if (attack_point)
-    *attack_point = move;
-  if (kworm)
-    *kworm = wpos;
-  if (certain)
-    *certain = result_certain;
 
-  return result;
+/* Undo an owl reading move. */
+static void
+owl_popgo(struct local_owl_data **owl)
+{
+  pop_owl(owl);
+  popgo();
 }
 
 
@@ -1844 +1853 @@
  */
 
 static int
-do_owl_attack(int str, int *move, int *wormid,
-              struct local_owl_data *owl, int escape)
+do_owl_attack(struct local_owl_data *owl, int *move, int *wormid)
 {
-  int color = board[str];
+  int color = board[owl->origin];
   int other = OTHER_COLOR(color);
   struct owl_move_data vital_moves[MAX_MOVES];
   struct owl_move_data shape_moves[MAX_MOVES];
@@ -1870 +1878 @@
   int value2;
   int this_variation_number = count_variations - 1;
   
-  SETUP_TRACE_INFO("owl_attack", str);
+  SETUP_TRACE_INFO("owl_attack", owl->origin);
 
   shape_patterns.initialized = 0;
 
-  str = find_origin(str);
+  owl->origin = find_origin(owl->origin);
 
-  if (tt_get(&ttable, OWL_ATTACK, str, NO_MOVE, depth - stackp, NULL, 
+  if (tt_get(&ttable, OWL_ATTACK, owl->origin, NO_MOVE, depth - stackp, NULL, 
              &value1, &value2, &xpos) == 2) {
 
     TRACE_CACHED_RESULT(value1, xpos);
@@ -1903 +1911 @@
   }
 
 
-  /* 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, 0, live_reason);
-    READ_RETURN(OWL_ATTACK, str, depth - stackp, move, 0, 0);
+    READ_RETURN(OWL_ATTACK, owl->origin, depth - stackp, move, 0, 0);
   }
 
   memset(mw, 0, sizeof(mw));
@@ -1948 +1956 @@
     SGFTRACE(0, acode, live_reason);
     TRACE("%oVariation %d: ALIVE (%s)\n", this_variation_number, live_reason);
     if (acode == 0) {
-      READ_RETURN(OWL_ATTACK, str, depth - stackp, move, 0, 0);
+      READ_RETURN(OWL_ATTACK, owl->origin, depth - stackp, move, 0, 0);
     }
     else {
       if (wormid)
         *wormid = saveworm;
-      READ_RETURN2(OWL_ATTACK, str, depth - stackp,
+      READ_RETURN2(OWL_ATTACK, owl->origin, depth - stackp,
                    move, mpos, acode, saveworm);
     }
   }
@@ -2018 +2026 @@
 
         sgf_dumptree = NULL;
         count_variations = 0;
-        result = attack(str, &apos);
+        result = attack(owl->origin, &apos);
         if (result == WIN
             || (result != 0 && (min_eyes(&probable_eyes) >= 2
                                 || pass == 5))) {
@@ -2036 +2044 @@
     case 4:
       if (number_tried_moves == 0) {
         int dpos;
-        int dcode = do_owl_defend(str, &dpos, NULL, owl, escape);
+        int dcode = do_owl_defend(owl, &dpos, NULL);
         /* No defense, we won. */
         if (dcode == 0) {
           TRACE("%oVariation %d: DEAD (no defense)\n",
                 this_variation_number);
           SGFTRACE(0, WIN, "no defense");
           close_pattern_list(other, &shape_patterns);
-          READ_RETURN(OWL_ATTACK, str, depth - stackp, move, 0, WIN);
+          READ_RETURN(OWL_ATTACK, owl->origin, depth - stackp, move, 0, WIN);
         }
         else if (dpos != NO_MOVE) {
           /* The dragon could be defended by one more move. Try to
@@ -2098 +2106 @@
       TRACE("%oVariation %d: ALIVE (escaped)\n", this_variation_number);
       SGFTRACE(0, 0, "escaped");
       close_pattern_list(other, &shape_patterns);
-      READ_RETURN0(OWL_ATTACK, str, depth - stackp);
+      READ_RETURN0(OWL_ATTACK, owl->origin, depth - stackp);
     }
 #endif
 
@@ -2112 +2120 @@
     for (k = 0; k < MAX_MOVES; k++) {
       int mpos;
       int ko_move = -1;
-      int origin = NO_MOVE;
       int captured;
       int wid = MAX_GOAL_WORMS;
       int dcode;
@@ -2144 +2151 @@
       /* Have we already tested this move? */
       if (mw[mpos])
         continue;
+      else
+        mw[mpos] = 1;
 
       captured = (color == WHITE ? white_captured : black_captured);
 
-      /* Try to make the move. */
-      if (!komaster_trymove(mpos, other, moves[k].name, str,
-                            &ko_move, savecode == 0))
+      /* Play the move, push the owl data, and update the owl
+       * strucures after the move.
+       */
+      if (!owl_attack_trymove(mpos, &owl, &moves[k], &ko_move, savecode))
         continue;
-
+      
       captured = (color == WHITE ? white_captured : black_captured) - captured;
-
-      TRACE("Trying %C %1m. Escape = %d. Current stack: ",
-            other, mpos, escape);
-      if (verbose)
-        dump_stack();
-
-      /* We have now made a move. Analyze the new position. */
-      push_owl(&owl);
-      mw[mpos] = 1;
+      
       number_tried_moves++;
-      owl_update_boundary_marks(mpos, owl);
-      
-      /* If the origin of the dragon has been captured, we look
-       * for another string which was part of the original dragon,
-       * marked when stackp==0, which has not been captured. If no
-       * such string is found, owl_attack declares victory.
-       */
-      if (IS_STONE(board[str]))
-        origin = str;
-      else
-        origin = select_new_goal_origin(NO_MOVE, owl);
-
-      /* Test whether the move cut the goal dragon apart. */
-      if (moves[k].cuts[0] != NO_MOVE && origin != NO_MOVE) {
-        owl_test_cuts(owl->goal, owl->color, moves[k].cuts);
-        if (!owl->goal[origin])
-          origin = select_new_goal_origin(origin, owl);
+      if (owl->origin == NO_MOVE)
+        dcode = 0;
+      else {
+        dcode = do_owl_defend(owl, NULL, &wid);
       }
-      mark_goal_in_sgf(owl->goal);
 
-      if (origin == NO_MOVE)
-        dcode = 0;
-      else
-        dcode = do_owl_defend(origin, NULL, &wid, owl, escape);
-
       if (!ko_move) {
         if (dcode == 0) {
-          pop_owl(&owl);
-          popgo();
+          owl_popgo(&owl);
           if (sgf_dumptree) {
             const char *wintxt;
             char winstr[192];
-            if (origin == NO_MOVE)
+            if (owl->origin == NO_MOVE)
               wintxt = "all original stones captured";
             else
               wintxt = "attack effective";
@@ -2204 +2186 @@
             SGFTRACE(mpos, WIN, winstr);
           }
           close_pattern_list(other, &shape_patterns);
-          READ_RETURN(OWL_ATTACK, str, depth - stackp, move, mpos, WIN);
+          READ_RETURN(OWL_ATTACK, owl->origin, depth - stackp,
+                      move, mpos, WIN);
         }
         else if (experimental_owl_ext && dcode == LOSS) {
           if (saveworm == MAX_GOAL_WORMS
@@ -2270 +2253 @@
           number_tried_moves--;
         }
       }
-    
-      pop_owl(&owl);
-      popgo();
+      owl_popgo(&owl);
     }
   }
 
@@ -2283 +2264 @@
       SGFTRACE(savemove, savecode, "attack effective (gain) - E");
       if (wormid)
         *wormid = saveworm;
-      READ_RETURN2(OWL_ATTACK, str, depth - stackp,
+      READ_RETURN2(OWL_ATTACK, owl->origin, depth - stackp,
                    move, savemove, savecode, saveworm);
     }
     else {
       SGFTRACE(savemove, savecode, "attack effective (ko) - E");
-      READ_RETURN(OWL_ATTACK, str, depth - stackp, move, savemove, savecode);
+      READ_RETURN(OWL_ATTACK, owl->origin, depth - stackp,
+                  move, savemove, savecode);
     }
   }
 
@@ -2299 +2281 @@
     SGFTRACE(0, 0, winstr);
   }
   
-  READ_RETURN0(OWL_ATTACK, str, depth - stackp);
+  READ_RETURN0(OWL_ATTACK, owl->origin, depth - stackp);
 }
 
 
-/* Returns true if the dragon at (target) can be captured given
- * two moves in a row. The first two moves to capture the
- * dragon are given as (*attack1) and (*attack2).
- */
+/* Static function containing the main recursive code for owl_defend. */
 
-int
-owl_threaten_attack(int target, int *attack1, int *attack2)
-{
-  struct owl_move_data moves[MAX_MOVES];
-  int k;
-  int other = OTHER_COLOR(board[target]);
-  struct local_owl_data *owl;
-  int result = 0;
-  int reading_nodes_when_called = get_reading_node_counter();
-  signed char saved_boundary[BOARDMAX];
-  double start = 0.0;
-  int tactical_nodes;
-  int move = 0;
-  int move2 = 0;
-  struct matched_patterns_list_data shape_patterns;
-
-  shape_patterns.initialized = 0;
-  result_certain = 1;
-  if (search_persistent_owl_cache(OWL_THREATEN_ATTACK, target, 0, 0,
-                                  &result, attack1, attack2, NULL))
-    return result;
-
-  if (debug & DEBUG_OWL_PERFORMANCE)
-    start = gg_cputime();
-  
-  gg_assert(stackp == 0);
-  TRACE("owl_threaten_attack %1m\n", target);
-  init_owl(&owl, target, NO_MOVE, NO_MOVE, 1, NULL);
-  memcpy(saved_boundary, owl->boundary, sizeof(saved_boundary));
-  owl_make_domains(owl, NULL);
-  owl_shapes(&shape_patterns, moves, other, owl, &owl_attackpat_db);
-  for (k = 0; k < MAX_MOVES; k++) {
-    current_owl_data = owl;
-    if (!get_next_move_from_list(&shape_patterns, other, moves, 1, owl))
-      break;
-    else {
-      int mpos = moves[k].pos;
-
-      if (mpos != NO_MOVE && moves[k].value > 0)
-        if (trymove(mpos, other, moves[k].name, target)) {
-          int pos;
-          int origin = NO_MOVE;
-          owl->lunches_are_current = 0;
-          owl_update_boundary_marks(mpos, owl);
-          
-          /* If the origin of the dragon has been captured, we look
-           * for another string which was part of the original dragon,
-           * marked when stackp==0, which has not been captured. If no
-           * such string is found, owl_attack declares victory.
-           */
-          
-          if (board[target] == EMPTY) {
-            for (pos = BOARDMIN; pos < BOARDMAX; 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)) {
-              /* probably this can't happen */
-              popgo();
-              gg_assert(stackp == 0);
-              result = 1;
-              break;
-            }
-          }
-          else if (do_owl_attack(target, &move2, NULL, owl, 0) == WIN) {
-            move = moves[k].pos;
-            popgo();
-            gg_assert(stackp == 0);
-            result = 1;
-            break;
-          }
-          popgo();
-          memcpy(owl->boundary, saved_boundary, sizeof(saved_boundary));
-        }
-    }
-  }
-  tactical_nodes = get_reading_node_counter() - reading_nodes_when_called;
-  gg_assert(stackp == 0);
-
-  DEBUG(DEBUG_OWL_PERFORMANCE,
-    "owl_threaten_attack %1m %1m %1m, result %d (%d, %d nodes, %f seconds)\n",
-    target, move, move2, result, local_owl_node_counter,
-    tactical_nodes, gg_cputime() - start);
-
-  store_persistent_owl_cache(OWL_THREATEN_ATTACK, target, 0, 0,
-                             result, move, move2, 0,
-                             tactical_nodes, owl->goal, board[target]);
-
-  if (attack1)
-    *attack1 = move;
-  if (attack2)
-    *attack2 = move2;
-
-  close_pattern_list(other, &shape_patterns);
-  return result;
-}
-
-
-/* Returns true if a move can be found to defend the dragon
- * at (target), in which case (*defense_point) is the recommended move.
- * (defense_point) can be a null pointer if the result is not needed.
- *
- * The array goal marks the extent of the dragon. This must
- * be maintained during reading. Call this function only when
- * stackp==0; otherwise you can call do_owl_attack but you must
- * set up the goal and boundary arrays by hand first.
- *
- * Returns KO_A or KO_B if the position is ko:
- *
- * - Returns KO_A if the defendse succeeds provided the defender is willing to
- *   ignore any ko threat (the defender makes the first ko capture).
- * - Returns KO_B if the defense succeeds provided the defender has a ko threat
- *   which must be answered (the attacker makes the first ko capture).
- *
- * If GNU Go is compiled with `configure --enable-experimental-owl-ext'
- * then a return codes of GAIN is also possible.
- *
- * - Returns LOSS if the defense succeeds but another worm of the
- *   defender's is captured in during the defense. The location
- *   of the killed worm is returned through the *kworm field.
- *
- * The array goal marks the extent of the dragon. This must
- * be maintained during reading.  
- */
-
-int
-owl_defend(int target, int *defense_point, int *certain, int *kworm)
-{
-  int result;
-  static struct local_owl_data *owl;
-  int reading_nodes_when_called = get_reading_node_counter();
-  double start = 0.0;
-  int tactical_nodes;
-  int move = NO_MOVE;
-  int wpos = NO_MOVE;
-  int wid = MAX_GOAL_WORMS;
-
-  result_certain = 1;
-  if (worm[target].unconditional_status == DEAD)