Ticket #107: gunnar_7_9.14b.diff

doc/gtp-commands.texi

@@ -762 +762 @@
 @cindex analyze_eyegraph
 @item analyze_eyegraph: Compute an eyevalue and vital points for an eye graph
 @verbatim
-Arguments: Eyeshape encoded in string
+Arguments: Eyeshape encoded in string OR two integers followed by eyeshape
 Fails:     Bad eyeshape, analysis failed
 Returns:   Eyevalue, vital points
 @end verbatim

engine/liberty.h

@@ -664 +664 @@
 int max_eye_value(int pos);
 void test_eyeshape(int eyesize, int *eye_vertices);
 int analyze_eyegraph(const char *coded_eyegraph, struct eyevalue *value,
-                     char *analyzed_eyegraph);
+                     char *analyzed_eyegraph, int outer_liberties,
+                     int ko_threats);
 
 
 /* debugging support */

engine/optics.c

@@ -2657 +2691 @@
  * 3 - result has been computed and was a success (1)
  */
 
+/* Types of vertices under consideration. */
+#define REGULAR       0
+#define OUTER_LIBERTY 1
+#define EXTRA_EYE     2
+#define KO_THREAT     3
+
+#define MAX_OUTER_LIBERTIES 4
+#define MAX_KO_THREATS      4
+
+struct vertex_data {
+  int pos[MAX_BOARD];
+  int type[MAX_BOARD];
+  int num;
+  int ko_threat_pos[MAX_KO_THREATS];
+  int num_ko_threats;
+  int num_ordinary;
+  int komaster;
+  int extra_eye_pos;
+  int string;
+};
+
 /* Like trymove() except that it does a superko check. This does,
- * however, only disallow repetition (besides simple ko) if the move
- * does not capture any stones.
+ * however, only disallow repetition (besides simple ko) for the
+ * attacker. 
+ *
+ * In order to cope with bent four in the corner, white is given one
+ * free virtual ko threat, which black can eliminate by spending a
+ * move playing on the "ko threat vertex". This has the side effect
+ * that white wins all direct kos, which is mostly okay until ko
+ * dependent eye values are implemented. It can, however, cause attack
+ * and defense points dependent on ko to be recommended together with
+ * non-ko vital points.
  */
+
+static int forced_ko_threat_stackp[MAX_KO_THREATS];
+static int num_active_ko_threats = 0;
+
 static int
-eyegraph_trymove(int pos, int color, const char *message, int str)
+eyegraph_trymove(int pos, int color, const char *message, int str,
+                 struct vertex_data *vertices)
 {
   static Hash_data remembered_board_hashes[MAXSTACK];
   int k;
-  int does_capture = does_capture_something(pos, color);
   
   remembered_board_hashes[stackp] = board_hash;
-  
-  if (!trymove(pos, color, message, str))
-    return 0;
 
-  if (does_capture)
+  if (!trymove(pos, color, message, str)) {
+    int ko_threat_pos = NO_MOVE;
+
+    if (!vertices)
+      return 0;
+    
+    if (color != vertices->komaster
+        || is_suicide(pos, color))
+      return 0;
+
+    for (k = 0; k < vertices->num_ko_threats; k++)
+      if (board[vertices->ko_threat_pos[k]] == EMPTY) {
+        ko_threat_pos = vertices->ko_threat_pos[k];
+        break;
+      }
+
+    if (ko_threat_pos != NO_MOVE) {
+      trymove(ko_threat_pos, BLACK, "making/answering virtual ko threat", str);
+      forced_ko_threat_stackp[num_active_ko_threats++] = stackp;
+      trymove(pos, color, message, str);
+    }
+    else
+      return 0;
+  }
+
+  if (color == WHITE)
     return 1;
 
   for (k = 0; k < stackp; k++)
@@ -2685 +2774 @@
   return 1;
 }
 
+static void
+eyegraph_popgo(void)
+{
+  popgo();
+
+  if (num_active_ko_threats > 0
+      && forced_ko_threat_stackp[num_active_ko_threats - 1] == stackp) {
+    popgo();
+    num_active_ko_threats--;
+  }
+}
+
+/* Has the vertex a neighbor which is connected to an invincible black
+ * string?
+ */
 static int
 eyegraph_is_margin_or_outer_liberty(int vertex)
 {
@@ -2711 +2815 @@
 }
 
 static int
-eyegraph_order_moves(int num_vertices, int *vertices, int color_to_move, int *moves)
+eyegraph_order_moves(struct vertex_data *vertices, int color_to_move,
+                     int *moves)
 {
   int num_moves = 0;
   int scores[BOARDMAX];
@@ -2720 +2825 @@
   int k;
   int r;
 
-  for (k = 0; k < num_vertices; k++) {
-    if (k >= num_vertices - 3) {
+  for (k = 0; k < vertices->num; k++) {
+    if (vertices->type[k] != REGULAR) {
       /* Never useful for white to fill in outer liberties or a second eye. */
       if (color_to_move == WHITE)
         break;
-      /* No use playing the second outer liberty before the first one. */
-      if (k == num_vertices - 2 && board[vertices[num_vertices - 3]] == EMPTY)
+      /* No use playing a later outer liberty before the previous one. */
+      if (vertices->type[k] == OUTER_LIBERTY
+          && vertices->type[k - 1] == OUTER_LIBERTY
+          && board[vertices->pos[k - 1]] == EMPTY)
         continue;
     }
     
-    move = vertices[k];
+    move = vertices->pos[k];
     score = 0;
 
     if (board[move] != EMPTY)
       continue;
     
-    if (eyegraph_is_margin_or_outer_liberty(move)) {
-      if (k < num_vertices - 3)
+    if (eyegraph_is_margin_or_outer_liberty(move))
+      if (vertices->type[k] == REGULAR)
         score = 5; /* margin */
-      else
-        score = -10; /* outer liberty */
-    }
 
     if (accuratelib(move, color_to_move, 2, NULL) == 1)
       score -= 3;
@@ -2843 +2947 @@
     return (result); \
   } while (0);
 
-static int tactical_life_defend(int str, int num_vertices, int *vertices,
+static int tactical_life_defend(int str, struct vertex_data *vertices,
                                 unsigned char *results);
 
 /* Determine whether black can capture all white stones. */
 static int
-tactical_life_attack(int str, int num_vertices, int *vertices,
+tactical_life_attack(int str, struct vertex_data *vertices,
                      unsigned char *results)
 {
   int k;
@@ -2859 +2963 @@
   int moves[BOARDMAX];
 
   /* Compute hash value to index the result cache with. */
-  for (k = 0; k < num_vertices; k++) {
+  for (k = 0; k < vertices->num; k++) {
     hash *= 3;
-    hash += board[vertices[k]];
+    hash += board[vertices->pos[k]];
   }
   hash *= 2;
   hash += (board_ko_pos != NO_MOVE);
@@ -2885 +2989 @@
   results[hash] |= 1;
 
   /* Try to play on all relevant vertices. */
-  num_moves = eyegraph_order_moves(num_vertices, vertices,
-                                   OTHER_COLOR(board[str]), moves);
+  num_moves = eyegraph_order_moves(vertices, OTHER_COLOR(board[str]), moves);
   for (k = 0; k < num_moves; k++) {
     int move = moves[k];
     if (eyegraph_trymove(move, OTHER_COLOR(board[str]),
-                         "tactical_life_attack", str)) {
+                         "tactical_life_attack", str,
+                         vertices)) {
       /* We were successful if the white stones were captured or if no
        * defense can be found.
        */
       if (board[str] == EMPTY)
         result = 1;
       else
-        result = !tactical_life_defend(str, num_vertices, vertices, results);
+        result = !tactical_life_defend(str, vertices, results);
       
-      popgo();
+      eyegraph_popgo();
 
       if (result == 1) {
         /* Store the result (success) in the cache. */
@@ -2916 +3020 @@
 
 /* Determine whether white can live with all stones. */
 static int
-tactical_life_defend(int str, int num_vertices, int *vertices,
+tactical_life_defend(int str, struct vertex_data *vertices,
                      unsigned char *results)
 {
   int k;
@@ -2927 +3031 @@
   int moves[BOARDMAX];
   
   /* Compute hash value to index the result cache with. */
-  for (k = 0; k < num_vertices; k++) {
+  for (k = 0; k < vertices->num; k++) {
     hash *= 3;
-    ASSERT1(board[vertices[k]] <= 2, vertices[k]);
-    hash += board[vertices[k]];
+    ASSERT1(board[vertices->pos[k]] <= 2, vertices->pos[k]);
+    hash += board[vertices->pos[k]];
   }
   hash *= 2;
   hash += (board_ko_pos != NO_MOVE);
@@ -2954 +3058 @@
   results[hash] |= (1 << 2);
 
   /* Try to play on all relevant vertices. */
-  num_moves = eyegraph_order_moves(num_vertices, vertices, board[str], moves);
+  num_moves = eyegraph_order_moves(vertices, board[str], moves);
   for (k = 0; k < num_moves; k++) {
     int move = moves[k];
     if ((!is_suicide(move, OTHER_COLOR(board[str]))
          || does_capture_something(move, board[str]))
-        && eyegraph_trymove(move, board[str], "tactical_life_defend", str)) {
+        && eyegraph_trymove(move, board[str], "tactical_life_defend", str,
+                            vertices)) {
       /* We were successful if no attack can be found. */
-      result = !tactical_life_attack(str, num_vertices, vertices, results);
+      result = !tactical_life_attack(str, vertices, results);
       
-      popgo();
+      eyegraph_popgo();
 
       if (result == 1) {
         /* Store the result (success) in the cache. */
@@ -2974 +3079 @@
   }
 
   /* If no move worked, also try passing. */
-  if (!tactical_life_attack(str, num_vertices, vertices, results)) {
+  if (!tactical_life_attack(str, vertices, results)) {
     /* Store the result (success) in the cache. */
     results[hash] = (results[hash] & (~12)) | (3 << 2);
     EYEGRAPH_RETURN(1, "tactical_life_defend: win");
@@ -2991 +3096 @@
  * used or filled in before starting reading.
  */
 static void
-tactical_life(int have_eye, int num_vertices, int *vertices,
+tactical_life(int have_eye, struct vertex_data *vertices,
               int *attack_code, int *num_attacks, int *attack_points,
               int *defense_code, int *num_defenses, int *defense_points,
               unsigned char *results)
@@ -3007 +3112 @@
    * vertex we test to determine whether the white stones have been
    * captured.
    */
-  str = POS(1, 0);
+  str = vertices->string;
 
   if (board[str] == EMPTY) {
     /* The stones have already been captured, too late to defend. */
@@ -3020 +3125 @@
    * suicide the white stones can be considered dead.
    */
   if (!have_eye) {
-    if (!eyegraph_trymove(POS(0, 0), WHITE, "tactical_life-A", NO_MOVE)) {
+    if (!eyegraph_trymove(vertices->extra_eye_pos, WHITE, "tactical_life-A",
+                          NO_MOVE, NULL)) {
       *attack_code = WIN;
       *defense_code = 0;
       return;
@@ -3033 +3139 @@
   /* Call tactical_life_attack() and tactical_life_defend() to
    * determine status.
    */
-  if (tactical_life_attack(str, num_vertices, vertices, results)) {
+  if (tactical_life_attack(str, vertices, results)) {
     *attack_code = WIN;
-    if (tactical_life_defend(str, num_vertices, vertices, results))
+    if (tactical_life_defend(str, vertices, results))
       *defense_code = WIN;
   }
   else
@@ -3049 +3155 @@
   if (*attack_code != 0 && *defense_code != 0) {
     if (num_attacks != NULL && attack_points != NULL) {
       *num_attacks = 0;
-      num_moves = eyegraph_order_moves(num_vertices, vertices,
+      num_moves = eyegraph_order_moves(vertices,
                                        OTHER_COLOR(board[str]), moves);
       for (k = 0; k < num_moves; k++) {
         int move = moves[k];
         if (eyegraph_trymove(move, OTHER_COLOR(board[str]), "tactical_life-B",
-                             str)) {
+                             str, vertices)) {
           if (board[str] == EMPTY
-              || !tactical_life_defend(str, num_vertices, vertices, results))
+              || !tactical_life_defend(str, vertices, results))
             attack_points[(*num_attacks)++] = move;
-          popgo();
+          eyegraph_popgo();
         }
       }
     }
 
     if (num_defenses != NULL && defense_points != NULL) {
       *num_defenses = 0;
-      num_moves = eyegraph_order_moves(num_vertices, vertices, board[str],
-                                       moves);
+      num_moves = eyegraph_order_moves(vertices, board[str], moves);
       for (k = 0; k < num_moves; k++) {
         int move = moves[k];
-        if (eyegraph_trymove(move, board[str], "tactical_life-C", str)) {
-          if (!tactical_life_attack(str, num_vertices, vertices, results))
+        if (eyegraph_trymove(move, board[str], "tactical_life-C", str,
+                             vertices)) {
+          if (!tactical_life_attack(str, vertices, results))
             defense_points[(*num_defenses)++] = move;
-          popgo();
+          eyegraph_popgo();
         }
       }
     }
@@ -3080 +3186 @@
 
   /* Unfill the extra eye if we didn't use it. */
   if (!have_eye)
-    popgo();
+    eyegraph_popgo();
 }
 
 /* Determine the eye value of the eyespace for the big white group on
@@ -3095 +3201 @@
  * need to recursively call ourselves after a move has been made.
  */
 static void
-evaluate_eyespace(struct eyevalue *result, int num_vertices, int *vertices,
+evaluate_eyespace(struct eyevalue *result, struct vertex_data *vertices,
                   int *num_vital_attacks, int *vital_attacks,
                   int *num_vital_defenses, int *vital_defenses,
                   unsigned char *tactical_life_results)
@@ -3123 +3229 @@
   *num_vital_defenses = 0;
 
   /* Determine tactical life without an extra eye. */
-  tactical_life(0, num_vertices, vertices,
+  tactical_life(0, vertices,
                 &attack_code, &num_attacks, attack_points,
                 &defense_code, &num_defenses, defense_points,
                 tactical_life_results);
@@ -3139 +3245 @@
     if (sgf_dumptree)
       sgftreeAddComment(sgf_dumptree, "Alive without extra eye.\n");
     
-    num_moves = eyegraph_order_moves(num_vertices, vertices, BLACK, moves);
+    num_moves = eyegraph_order_moves(vertices, BLACK, moves);
     for (k = 0; k < num_moves; k++) {
       int acode, dcode;
       int move = moves[k];
-      if (eyegraph_trymove(move, BLACK, "evaluate_eyespace-A", NO_MOVE)) {
-        tactical_life(0, num_vertices, vertices, &acode, NULL, NULL,
+      if (eyegraph_trymove(move, BLACK, "evaluate_eyespace-A", NO_MOVE,
+                           vertices)) {
+        tactical_life(0, vertices, &acode, NULL, NULL,
                       &dcode, NULL, NULL, tactical_life_results);
         if (acode != 0) {
-          tactical_life(1, num_vertices, vertices, &acode, NULL, NULL,
+          tactical_life(1, vertices, &acode, NULL, NULL,
                         &dcode, NULL, NULL, tactical_life_results);
           if (acode != 0) {
             if (a == 1)
@@ -3167 +3274 @@
               sgftreeAddComment(sgf_dumptree, "Ko threat to remove one eye.\n");
           }
         }
-        popgo();
+        eyegraph_popgo();
       }
     }
     set_eyevalue(result, a, 2, 2, 2);
@@ -3186 +3293 @@
      */
     if (sgf_dumptree)
       sgftreeAddComment(sgf_dumptree, "Critical without extra eye.\n");
-    tactical_life(1, num_vertices, vertices,
+    tactical_life(1, vertices,
                   &attack_code2, &num_attacks2, attack_points2,
                   &defense_code2, NULL, NULL, tactical_life_results);
     for (k = 0; k < num_defenses; k++)
@@ -3203 +3310 @@
       int a = 1;
       for (k = 0; k < num_attacks; k++) {
         int move = attack_points[k];
-        if (eyegraph_trymove(move, BLACK, "evaluate_eyespace-B", NO_MOVE)) {
-          evaluate_eyespace(&result2, num_vertices, vertices,
+        if (eyegraph_trymove(move, BLACK, "evaluate_eyespace-B", NO_MOVE,
+                             vertices)) {
+          evaluate_eyespace(&result2, vertices,
                             &num_vital_attacks2, vital_attacks2,
                             &num_vital_defenses2, vital_defenses2,
                             tactical_life_results);
@@ -3221 +3329 @@
           }
           else if (a == 1)
             vital_attacks[(*num_vital_attacks)++] = move;
-          popgo();
+          eyegraph_popgo();
         }
       }
       set_eyevalue(result, a, 1, 2, 2);
@@ -3241 +3349 @@
      */
     if (sgf_dumptree)
       sgftreeAddComment(sgf_dumptree, "Dead without extra eye.\n");
-    tactical_life(1, num_vertices, vertices,
+    tactical_life(1, vertices,
                   &attack_code, &num_attacks, attack_points,
                   &defense_code, &num_defenses, defense_points,
                   tactical_life_results);
@@ -3253 +3361 @@
       int d = 1;
       if (sgf_dumptree)
         sgftreeAddComment(sgf_dumptree, "Alive with extra eye.\n");
-      num_moves = eyegraph_order_moves(num_vertices, vertices, BLACK, moves);
+      num_moves = eyegraph_order_moves(vertices, BLACK, moves);
       for (k = 0; k < num_moves; k++) {
         int acode, dcode;
         int move = moves[k];
-        if (eyegraph_trymove(move, BLACK, "evaluate_eyespace-C", NO_MOVE)) {
-          tactical_life(1, num_vertices, vertices, &acode, NULL, NULL,
+        if (eyegraph_trymove(move, BLACK, "evaluate_eyespace-C", NO_MOVE,
+                             vertices)) {
+          tactical_life(1, vertices, &acode, NULL, NULL,
                         &dcode, NULL, NULL, tactical_life_results);
           if (acode != 0) {
-            evaluate_eyespace(&result2, num_vertices, vertices,
+            evaluate_eyespace(&result2, vertices,
                               &num_vital_attacks2, vital_attacks2,
                               &num_vital_defenses2, vital_defenses2,
                               tactical_life_results);
@@ -3273 +3382 @@
                 sgftreeAddComment(sgf_dumptree, "Attacking ko threat.\n");
             }
           }
-          popgo();
+          eyegraph_popgo();
         }
       }
       
-      num_moves = eyegraph_order_moves(num_vertices, vertices, WHITE, moves);
+      num_moves = eyegraph_order_moves(vertices, WHITE, moves);
       for (k = 0; k < num_moves; k++) {
         int acode, dcode;
         int move = moves[k];
-        if (eyegraph_trymove(move, WHITE, "evaluate_eyespace-D", NO_MOVE)) {
-          tactical_life(0, num_vertices, vertices, &acode, NULL, NULL,
+        if (eyegraph_trymove(move, WHITE, "evaluate_eyespace-D", NO_MOVE,
+                             vertices)) {
+          tactical_life(0, vertices, &acode, NULL, NULL,
                         &dcode, NULL, NULL, tactical_life_results);
           if (dcode != 0) {
-            evaluate_eyespace(&result2, num_vertices, vertices,
+            evaluate_eyespace(&result2, vertices,
                               &num_vital_attacks2, vital_attacks2,
                               &num_vital_defenses2, vital_defenses2,
                               tactical_life_results);
@@ -3297 +3407 @@
                 sgftreeAddComment(sgf_dumptree, "Defending ko threat.\n");
             }
           }
-          popgo();
+          eyegraph_popgo();
         }
       }
       set_eyevalue(result, a, 1, 1, d);
@@ -3323 +3433 @@
         vital_attacks[(*num_vital_attacks)++] = attack_points[k];
       for (k = 0; k < num_defenses; k++) {
         int move = defense_points[k];
-        if (eyegraph_trymove(move, WHITE, "evaluate_eyespace-E", NO_MOVE)) {
-          evaluate_eyespace(&result2, num_vertices, vertices,
+        if (eyegraph_trymove(move, WHITE, "evaluate_eyespace-E", NO_MOVE,
+                             vertices)) {
+          evaluate_eyespace(&result2, vertices,
                             &num_vital_attacks2, vital_attacks2,
                             &num_vital_defenses2, vital_defenses2,
                             tactical_life_results);
@@ -3341 +3452 @@
           }
           else if (d == 1)
             vital_defenses[(*num_vital_defenses)++] = move;
-          popgo();
+          eyegraph_popgo();
         }
       }
       set_eyevalue(result, 0, 0, 1, d);
@@ -3361 +3472 @@
       int d = 0;
       if (sgf_dumptree)
         sgftreeAddComment(sgf_dumptree, "Dead with extra eye.\n");
-      num_moves = eyegraph_order_moves(num_vertices, vertices, WHITE, moves);
+      num_moves = eyegraph_order_moves(vertices, WHITE, moves);
       for (k = 0; k < num_moves; k++) {
         int acode, dcode;
         int move = moves[k];
-        if (eyegraph_trymove(move, WHITE, "evaluate_eyespace-F", NO_MOVE)) {
-          tactical_life(1, num_vertices, vertices, &acode, NULL, NULL,
+        if (eyegraph_trymove(move, WHITE, "evaluate_eyespace-F", NO_MOVE,
+                             vertices)) {
+          tactical_life(1, vertices, &acode, NULL, NULL,
                         &dcode, NULL, NULL, tactical_life_results);
           if (dcode != 0) {
-            tactical_life(0, num_vertices, vertices, &acode, NULL, NULL,
+            tactical_life(0, vertices, &acode, NULL, NULL,
                           &dcode, NULL, NULL, tactical_life_results);
             if (dcode != 0) {
               if (d == 1)
@@ -3390 +3502 @@
                                   "Ko threat to make one eye.\n");
             }
           }
-          popgo();
+          eyegraph_popgo();
         }
       }
       set_eyevalue(result, 0, 0, 0, d);
@@ -3477 +3589 @@
  * !.*.
  *
  * If the eye graph cannot be realized, 0 is returned, 1 otherwise.
+ *
+ * The parameter outer_liberties determines how many external
+ * liberties will be attached, excluding the one which is sometimes
+ * provided by a second eye. Up to five outer liberties can be provided.
+ *
+ * The parameter ko_threats tells how many ko_threats one of the
+ * players is allowed to ignore. Positive values mean that the
+ * defender is allowed to ignore ko threats and negative that the
+ * attacker can do so. The other player is allowed to spend a move to
+ * reduce this number, which is usually not the best thing to do with
+ * a move but allows a correct understanding of the bent four in the
+ * corner shapes. At most 4 ignored ko threats are considered.
  */
 int
 analyze_eyegraph(const char *coded_eyegraph, struct eyevalue *value,
-                 char *analyzed_eyegraph)
+                 char *analyzed_eyegraph, int outer_liberties,
+                 int ko_threats)
 {
   int k;
   int i, j;
@@ -3488 +3613 @@
   int mx[BOARDMAX];
   char mg[BOARDMAX];
   int pos;
+  int corner;
+  int up;
+  int right;
 
   int num_vital_attacks;
   int vital_attacks[BOARDMAX]; /* Way larger than necessary. */
@@ -3503 +3631 @@
   int num_margins;
   int margins[BOARDMAX]; /* Way larger than necessary. */
 
-  int num_vertices;
-  int vertices[BOARDMAX]; /* Way larger than necessary. */
-
+  struct vertex_data vertices;
+  
   int table_size;
   unsigned char *tactical_life_results;
 
   if (0)
     gprintf("Analyze eyegraph %s\n", coded_eyegraph);
+
+  gg_assert(outer_liberties >= 0 && outer_liberties <= 5);
+  gg_assert(ko_threats >= -4 && ko_threats <= 4);
+  
+  if (ko_threats > 0)
+    vertices.komaster = WHITE;
+  else if (ko_threats == 0)
+    vertices.komaster = EMPTY;
+  else {
+    vertices.komaster = BLACK;
+    ko_threats = -ko_threats;
+  }
   
   /* Mark the eyespace in the mx array. We construct the position in
    * the mx array and copy it to the actual board later.
@@ -3530 +3669 @@
   for (k = 0; k < (int) strlen(coded_eyegraph); k++) {
     if (coded_eyegraph[k] == '\n')
       continue;
+    if (coded_eyegraph[k] == ' ')