Ticket #1: splee_5_5.1d.diff

engine/reading.c

@@ -299 +299 @@
                         int color, const char *funcname, int killer);
 static int simple_ladder_defend(int str, int *move);
 static int in_list(int move, int num_moves, int *moves);
+static int is_single(int pos, int color);
 
 
 /* Statistics. */
@@ -4467 +4468 @@
 
     /* If the 3 liberty chain easily can run away through one of the
      * liberties, we don't play on any of the other liberties.
+     * The heuristic for "easily run away" is defined as:
+     * 1. Playing on any of the 3 liberties of the chain and the resulting
+     *    number of liberty of the chain will be less than 4. Or
+     * 2. Playing on the 3 liberties in turn will resulting in:
+     *    4 or more liberties, 4 or less liberties and less than
+     *    4 liberties. In this case we only try one breaking chain move
+     *    on the position with escape potential of 4 or more liberties.
      */
     lib1 = approxlib(libs[0], other, 4, NULL);
     lib2 = approxlib(libs[1], other, 4, NULL);
-    if (lib1 >= 4 && lib2 >= 4)
-      continue;
     lib3 = approxlib(libs[2], other, 4, NULL);
 
-    if ((lib1 >= 4 || lib2 >= 4) && lib3 >= 4)
-      continue;
-
     if (lib1 >= 4) {
-      if (!move_added[libs[0]]) {
+      /* For the safety of the breaking chain move,
+       * the move must be either a single stone, or a resulting
+       * string of 4 or more liberties
+       */
+      if (((lib2 <= 4 && lib3 < 4)
+            || (lib3 <= 4 && lib2 < 4))
+          && ((is_single(libs[0], color)
+              || approxlib(libs[0], color, 4, NULL) > 3))
+          && !move_added[libs[0]]) {
         possible_moves[num_possible_moves++] = libs[0];
         move_added[libs[0]] = 1;
       }
-
       continue;
     }
 
     if (lib2 >= 4) {
-      if (!move_added[libs[1]]) {
+      if (((lib1 <= 4 && lib3 < 4)
+            || (lib3 <= 4 && lib1 < 4))
+          && (is_single(libs[1], color)
+              || approxlib(libs[1], color, 4, NULL) > 3)
+          && !move_added[libs[1]]) {
         possible_moves[num_possible_moves++] = libs[1];
         move_added[libs[1]] = 1;
       }
-
       continue;
     }
 
     if (lib3 >= 4) {
-      if (!move_added[libs[2]]) {
+      if (((lib2 <= 4 && lib1 < 4)
+            || (lib1 <= 4 && lib2 < 4))
+          && (is_single(libs[2], color)
+              || approxlib(libs[2], color, 4, NULL) > 3)
+          && !move_added[libs[2]]) {
         possible_moves[num_possible_moves++] = libs[2];
         move_added[libs[2]] = 1;
       }
@@ -4504 +4521 @@
       continue;
     }
 
+    if (lib1 >= 4 || lib2 >= 4 || lib3 >= 4)
+      continue;
+
     /* No easy escape, try all liberties. */
     for (k = 0; k < 3; k++) {
       if (!move_added[libs[k]]) {
@@ -4557 +4577 @@
   }
 }
 
+static int
+is_single(int pos, int color)
+{
+  if ((board[SOUTH(pos)] != color) && (board[EAST(pos)] != color) &&
+      (board[WEST(pos)] != color) && (board[NORTH(pos)] != color))
+    return(1);
+  return(0);
+}
 
 /*
  * (str) points to a group.