Ticket #163: draqo-semeai.diff

engine/owl.c

@@ -2 +2 @@
  * This is GNU Go, a Go program. Contact gnugo@gnu.org, or see       *
  * http://www.gnu.org/software/gnugo/ for more information.          *
  *                                                                   *
- * Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005 and 2006       *
+ * Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 and 2007 *
  * by the Free Software Foundation.                                  *
  *                                                                   *
  * This program is free software; you can redistribute it and/or     *
@@ -670 +670 @@
   struct eyevalue probable_eyes_a;
   struct eyevalue probable_eyes_b;
   struct eyevalue dummy_eyes;
+  int I_have_more_eyes;
   
   SETUP_TRACE_INFO2("do_owl_analyze_semeai", apos, bpos);
 
@@ -804 +805 @@
   if (!owl_phase) {
     set_eyevalue(&probable_eyes_a, 0, 0, 0, 0);
     set_eyevalue(&probable_eyes_b, 0, 0, 0, 0);
+    I_have_more_eyes = 0;
   }
   else {
     /* First the vital moves. These include moves to attack or
@@ -893 +895 @@
                                      shape_defensive_moves, 1, owla))
           break;
     }
+    else
+      shape_defensive_moves[0].pos = 0;
+
     if (!you_look_alive) {
       owl_shapes(&shape_offensive_patterns, shape_offensive_moves, color,
                  owlb, &owl_attackpat_db);
@@ -901 +906 @@
                                      shape_offensive_moves, 1, owlb))
           break;
     }
+    else
+      shape_offensive_moves[0].pos = 0;
+
+    /* Filter out moves, which fills our eye (and not split it). */
+    if (eyemax_a) {
+      int n;
+      struct owl_move_data *checked_moves;
+
+      for (n = 1; n <= 5; n++) {
+        switch (n) {
+        case 1:
+          checked_moves = moves;
+          break;
+        case 2:
+          checked_moves = vital_defensive_moves;
+          break;
+        case 3:
+          checked_moves = vital_offensive_moves;
+          break;
+        case 4:
+          checked_moves = shape_defensive_moves;
+          break;
+        case 5:
+          checked_moves = shape_offensive_moves;
+          break;
+        default:
+          checked_moves = NULL;
+          gg_assert(0);
+        }
+
+        for (k = 0; k < MAX_MOVES; k++) {
+          if (checked_moves[k].pos <= 0)
+            break;
+          else {
+            struct eye_data *eye = &owla->my_eye[checked_moves[k].pos];
+
+            /* If esize==1 this eye must not be a real eye (at least one
+             * worm is capturable, otherwise this move would not be
+             * proposed).
+             */
+            if (eye->color == color && eye->msize == 0 && eye->neighbors <= 1
+                && eye->esize != 1
+                && owla->half_eye[checked_moves[k].pos].type != HALF_EYE
+                && !has_neighbor(checked_moves[k].pos, OTHER_COLOR(color)))
+              checked_moves[k].value = 0;
+          }
+        }
+      }
+    }
 
     /* Now we review the moves already considered, while collecting
      * them into a single list. 
@@ -956 +1010 @@
       include_semeai_worms_in_eyespace = 0;
     }
 
+    if (eyemin_a == eyemax_a)
+      /* We have stable number of eyes, so we can try to reduce
+       * opponent eyes. */
+      I_have_more_eyes = (eyemin_a > min_eyes(&probable_eyes_b));
+    else {
+      if (min_eyes(&probable_eyes_a) == max_eyes(&probable_eyes_a))
+        /* If we can't increase our number of eyes, we try to reduce
+         * opponent eyes. */
+        I_have_more_eyes = (max_eyes(&probable_eyes_a) > min_eyes(&probable_eyes_b));
+      else
+        /* If we can increase our number of eyes, we do it and let
+         * opponent to increase his. */
+        I_have_more_eyes = (max_eyes(&probable_eyes_a) > max_eyes(&probable_eyes_b));
+    }
+
     if (get_level() < 8) {
       /* If no owl moves were found on two consecutive moves,
        * turn off the owl phase.
@@ -979 +1048 @@
   
   /* Now we look for a move to fill a liberty. This is only
    * interesting if the opponent doesn't already have two eyes.
+   * If we have more eyes, always check for a backfilling move.
    */
   if (!you_look_alive
-      && !safe_outside_liberty_found && moves[0].value < 110) {
+      && !safe_outside_liberty_found
+      && (moves[0].value < 110 || I_have_more_eyes)) {
     int pos;
     for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
       if (!ON_BOARD(pos))
-        continue;
+        continue;
       
       if (board[pos] == EMPTY && !mw[pos]) {
         if (liberty_of_goal(pos, owlb)) {
@@ -997 +1068 @@
               break;
             }
             else if (backfill_outside_liberty.pos == NO_MOVE)
-              backfill_outside_liberty.pos = find_semeai_backfilling_move(bpos,
-                                                                          pos);
+              backfill_outside_liberty.pos =
+                find_semeai_backfilling_move(bpos, pos);
           }
           else {
             /* common liberty */
@@ -1007 +1078 @@
               common_liberty.pos = pos;
             }
             else if (backfill_common_liberty.pos == NO_MOVE)
-              backfill_common_liberty.pos = find_semeai_backfilling_move(bpos,
-                                                                         pos);
+              backfill_common_liberty.pos =
+                find_semeai_backfilling_move(bpos, pos);
           }
         }
       }
@@ -1095 +1166 @@
     if (mpos == NO_MOVE)
       break;
 
+    if (moves[k].value == 0)
+      continue;
+
     /* Do not try too many moves. */
     if (tested_moves > 2
         || (stackp > semeai_branch_depth2 && tested_moves > 1)
@@ -1283 +1357 @@
   gg_assert(this_resulta != NULL && this_resultb != NULL);
   *this_resulta = 0;
   *this_resultb = 0;
-  if (!komaster_trymove(move, color, move_name, apos, &ko_move, ko_allowed))
+
+  if (!komaster_trymove(move, color, move_name, apos, &ko_move, ko_allowed)) {
+    int kpos;
+    if (is_ko(move, color, &kpos)) {
+      /* Move was not allowed because of komaster. We want to check, if this
+       * situation is double ko and when it is, we won semeai.
+       */
+      int libs[MAX_LIBERTIES];
+      int n;
+      int nlib;
+      int sworm;
+      int worm_color;
+      int other = OTHER_COLOR(color);
+
+      for (sworm = 0; sworm < s_worms; sworm++) {
+        worm_color = board[semeai_worms[sworm]];
+        if (worm_color == color) {
+          /* We only check up to MAX_LIBERTIES, due to performance reasons. When we
+           * have more liberties we have some outside liberties to fill and these
+           * moves will be tried later (and double ko situation will be found).
+           */
+          nlib = findlib(semeai_worms[sworm], MAX_LIBERTIES, libs);
+          if (nlib > MAX_LIBERTIES)
+            return 0;
+
+          for (n = 0; n < nlib; n++)
+            if (is_ko(libs[n], other, NULL)) {
+              /* Check if situation is not a nested ko capture. */
+              if (DIAGONAL_NEIGHBORS(libs[n], kpos))
+                return 0;
+
+              /* Our dragon has double ko, but we have to check if opponent dragon
+               * doesn't have outside liberties or double ko.
+               */
+              *this_resulta = WIN;
+              *this_resultb = WIN;
+            }
+        }
+        else if (worm_color == other) {
+          if (countlib(semeai_worms[sworm]) > 2)
+            /* In double ko situation the opponent can have only
+             * a single eye and a ko outside liberty to be sure that we
+             * will always win double ko. */
+            return 0;
+        }
+      }
+      if (*this_resulta == WIN)
+        return 1;
+    }
+
     return 0;
+  }
   
   semeai_add_sgf_comment(move_value, owl_phase);
   TRACE("Trying %C %1m. Current stack: ", color, move);
@@ -1453 +1577 @@
     if (move == NO_MOVE)
       break;
 
+    if (owl_moves[k].value == 0)
+      continue;
+
     /* Does the move fill a liberty in the semeai? */
     if (liberty_of_goal(move, owlb)
         && safe_move(move, color)) {
@@ -1578 +1705 @@
     for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
       if (IS_STONE(board[pos])
           && pos == find_origin(pos)) {
-        if (owla->goal[pos])
-          net -= 75*countlib(pos);
-        if (owlb->goal[pos])
-          net += 100*countlib(pos);       
+        int count_lib = -1;
+        if (owla->goal[pos]) {
+          count_lib = countlib(pos);
+          net -= 75 * count_lib;
+        }
+        if (owlb->goal[pos]) {
+          if (count_lib < 0)
+            count_lib = countlib(pos);
+          net += 100 * count_lib;
+        }
       }
     }
     if (!trymove(move, color, NULL, 0)) {
@@ -1591 +1724 @@
     for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
       if (IS_STONE(board[pos])
           && pos == find_origin(pos)) {
+        int count_lib = -1;
         if (owla->goal[pos]
-            || (pos == move && liberty_of_goal(move, owla)))
-          net += 75*countlib(pos);
-        if (owlb->goal[pos])
-          net -= 100*countlib(pos);
+            || (pos == move && liberty_of_goal(move, owla))) {
+          count_lib = countlib(pos);
+          net += 75 * count_lib;
+        }
+        if (owlb->goal[pos]) {
+          if (count_lib < 0)
+            count_lib = countlib(pos);
+          net -= 100 * count_lib;
+        }
       }
     }