Ticket #196: gunnar_7_12.4b.diff

engine/utils.c

@@ -1407 +1407 @@
 }
     
 
-/* Returns true if a move by (color) fits a shape like:
- *
- *  -----
- *  O.O*X        (O=color)
- *  OOXXX
- *
- * More specifically the move should have the following properties:
- * - The move is a self-atari
- * - The move forms a string of exactly two stones
- * - When the opponent captures, the capturing stone becomes a single
- *   stone in atari
- * - When capturing back the original position is repeated
- */
-
-int
-send_two_return_one(int move, int color)
-{
-  int other = OTHER_COLOR(color);
-  int lib1;
-  int lib2;
-
-  /* Try to play the move. */
-  if (!trymove(move, color, "send_two_return_one-A", NO_MOVE))
-    return 0;
-
-  /* Does the move leave exactly two stones in atari? */
-  if (findlib(move, 1, &lib1) > 1 || countstones(move) != 2) {
-    popgo();
-    return 0;
-  }
-
-  /* Let the opponent capture. This move is guaranteed to be legal. */
-  trymove(lib1, other, "send_two_return_one-A", NO_MOVE);
-
-  /* Is the capturing string single and in atari? */
-  if (findlib(lib1, 1, &lib2) > 1 || countstones(lib1) > 1) {
-    popgo();
-    popgo();
-    return 0;
-  }
-
-  popgo();
-  popgo();
-
-  /* The move to capture back is in lib2. This must be one of the two
-   * captured stones, either the move or the adjacent stone. If it is
-   * the same as the first move, the previous position is not repeated
-   * by capturing back, so we return false.
-   */
-  if (lib2 == move)
-    return 0;
-
-  /* The move matches the shape. */
-  return 1;
-}
-
-
 /* Returns true if a move by (color) plays into a snapback. */
 int
 playing_into_snapback(int move, int color)

engine/liberty.h

@@ -545 +545 @@
 int does_defend(int move, int str);
 int double_atari(int move, int color, float *value,
                  signed char safe_stones[BOARDMAX]);
-int send_two_return_one(int move, int color);
 int playing_into_snapback(int move, int color);
 int play_attack_defend_n(int color, int do_attack, int num_moves, ...);
 int play_attack_defend2_n(int color, int do_attack, int num_moves, ...);

engine/value_moves.c

@@ -161 +161 @@
   increase_depth_values();
   
   for (ii = BOARDMIN; ii < BOARDMAX; ii++) {
-    if (!ON_BOARD(ii))
+    if (board[ii] != EMPTY)
       continue;
 
     /* Don't consider send-two-return-one moves here. */

engine/board.c

@@ -2728 +2728 @@
 }
 
 
+/* Returns true if a move by (color) fits a shape like:
+ *
+ *  -----
+ *  O.O*X        (O=color)
+ *  OOXXX
+ *
+ * More specifically the move should have the following properties:
+ * - The move is a self-atari
+ * - The move forms a string of exactly two stones
+ * - When the opponent captures, the capturing stone becomes a single
+ *   stone in atari
+ * - When capturing back the original position is repeated
+ */
+
+int
+send_two_return_one(int move, int color)
+{
+  int other = OTHER_COLOR(color);
+  int lib = NO_MOVE;
+  int friendly_neighbor = NO_MOVE;
+  int k;
+  
+  ASSERT1(board[move] == EMPTY, move);
+
+  for (k = 0; k < 4; k++) {
+    int pos = move + delta[k];
+    if (board[pos] == EMPTY)
+      return 0;
+    if (board[pos] == color) {
+      int s;
+      if (friendly_neighbor != NO_MOVE)
+        return 0;
+      friendly_neighbor = pos;
+      s = string_number[pos];
+      if (string[s].size != 1 || string[s].liberties != 2)
+        return 0;
+      lib = string_libs[s].list[0] + string_libs[s].list[1] - move;
+    }
+    else if (board[pos] == other
+             && string[string_number[pos]].liberties == 1)
+      return 0;
+  }
+  
+  if (friendly_neighbor == NO_MOVE)
+    return 0;
+
+  for (k = 0; k < 4; k++) {
+    int pos = lib + delta[k];
+    if (board[pos] == EMPTY || board[pos] == other)
+      return 0;
+    if (board[pos] == color &&
+        string[string_number[pos]].liberties < 2)
+      return 0;
+  }
+  
+  return 1;
+}
+
+
 /*
  * Find the origin of a worm, i.e. the point with the
  * smallest 1D board coordinate. The idea is to have a canonical

engine/board.h

@@ -345 +345 @@
 int findstones(int str, int maxstones, int *stones);
 int count_adjacent_stones(int str1, int str2, int maxstones);
 
+/* Detect a special shape. */
+int send_two_return_one(int move, int color);
+
 /* Special function for reading.c */
 void incremental_order_moves(int move, int color, int string,
                              int *number_edges, int *number_same_string,