Ticket #132: gunnar_7_10.13b.diff

TODO

@@ -61 +61 @@
 
  * Make the cache not waste storage on 64 bit systems.
 
- * Implement detection of superko violation in the board code. We
-   probably only want this optionally in play_move() and in a variant
-   of is_legal().
-
  * The dragon data is split into two arrays, dragon[] and dragon2[].
    The dragon2 array only have one entry per dragon, in contrast to
    the dragon array where all the data is stored once for every

doc/introduction.texi

@@ -206 +206 @@
 halfway done.  The moves are stored, but not the attack and defend
 codes (LOSE, KO_A, KO_B and WIN).
 @item Make the cache not waste storage on 64 bit systems.
-@item  Implement detection of superko violation in the board code. We
-probably only want this optionally in @code{play_move()} and in a variant
-of @code{is_legal()}.
 @item The dragon data is split into two arrays, @code{dragon[]}
 and @code{dragon2[]}. The dragon2 array only have one entry per dragon, in
 contrast to the dragon array where all the data is stored once for every

doc/using.texi

@@ -496 +496 @@
 Use Japanese Rules. This is the default unless you specify
 @option{--enable-chinese-rules} as a configure option.
 @end quotation
+@item @option{--forbid-suicide} 
+@quotation
+Do not allow suicide moves (playing a stone so that it ends up without
+liberties and is therefore immediately removed). This is the default.
+@end quotation
+@item @option{--allow-suicide} 
+@quotation
+Allow suicide moves, except single-stone suicide. The latter would not
+change the board at all and pass should be used instead.
+@end quotation
+@item @option{--allow-all-suicide} 
+@quotation
+Allow suicide moves, including single-stone suicide. This is only
+interesting in exceptional cases. Normally the
+@option{--allow-suicide} option should be used instead.
+@end quotation
+@item @option{--simple-ko} 
+@quotation
+Do not allow an immediate recapture of a ko so that the previous
+position is recreated. Repetition of earlier positions than that are
+allowed. This is default.
+@end quotation
+@item @option{--no-ko} 
+@quotation
+Allow all kinds of board repetition.
+@end quotation
+@item @option{--positional-superko} 
+@quotation
+Forbid repetition of any earlier board position. This only applies to
+moves on the board; passing is always allowed.
+@end quotation
+@item @option{--situational-superko} 
+@quotation
+Forbid repetition of any earlier board position with the same player
+to move. This only applies to moves on the board; passing is always
+allowed.
+@end quotation
 @item @option{--copyright}: Display the copyright notice
 @item @option{--version} or @option{-v}: Print the version number
 @item @option{--printsgf @var{filename}}: 

engine/board.c

@@ -300 +300 @@
 
 
 /* Forward declarations. */
+static void really_do_trymove(int pos, int color);
 static int do_trymove(int pos, int color, int ignore_ko);
 static void undo_trymove(void);
 
@@ -307 +308 @@
 static int slow_approxlib(int pos, int color, int maxlib, int *libs);
 static int do_accuratelib(int pos, int color, int maxlib, int *libs);
 
+static int is_superko_violation(int pos, int color, enum ko_rules type);
+
 static void new_position(void);
 static int propagate_string(int stone, int str);
 static void find_liberties_and_neighbors(int s);
@@ -360 +363 @@
   for (k = 0; k < move_history_pointer; k++) {
     state->move_history_color[k] = move_history_color[k];
     state->move_history_pos[k] = move_history_pos[k];
+    state->move_history_hash[k] = move_history_hash[k];
   }
 
   state->komi = komi;
@@ -396 +400 @@
   for (k = 0; k < move_history_pointer; k++) {
     move_history_color[k] = state->move_history_color[k];
     move_history_pos[k] = state->move_history_pos[k];
+    move_history_hash[k] = state->move_history_hash[k];
   }
 
   komi = state->komi;
@@ -598 +603 @@
   return 1;
 }
 
+/* Really, really make a temporary move. It is assumed that all
+ * necessary checks have already been made and likewise that various
+ * administrative bookkeeping outside of the actual board logic has
+ * either been done or is not needed.
+ */
+static void
+really_do_trymove(int pos, int color)
+{
+  BEGIN_CHANGE_RECORD();
+  PUSH_VALUE(board_ko_pos);
+
+  /*
+   * FIXME: Do we really have to store board_hash in a stack?
+   *
+   * Answer: No, we don't.  But for every stone that we add
+   *         or remove, we must call hashdata_invert_stone(). This is
+   *         not difficult per se, but the whole board.c 
+   *         will have to be checked, and there is lots of room
+   *         for mistakes.
+   *
+   *         At the same time, profiling shows that storing the
+   *         hashdata in a stack doesn't take a lot of time, so
+   *         this is not an urgent FIXME.
+   */
+  memcpy(&board_hash_stack[stackp], &board_hash, sizeof(board_hash));
+
+  if (board_ko_pos != NO_MOVE)
+    hashdata_invert_ko(&board_hash, board_ko_pos);
+
+  board_ko_pos = NO_MOVE;
+  
+  stackp++;
+
+  if (pos != PASS_MOVE) {
+    PUSH_VALUE(black_captured);
+    PUSH_VALUE(white_captured);
+    do_play_move(pos, color);
+  }
+}
 
 /*
  * Do the main work of trymove() and tryko(), i.e. the common parts.
@@ -663 +707 @@
   stack[stackp] = pos;
   move_color[stackp] = color;
 
-  /*
-   * FIXME: Do we really have to store board_hash in a stack?
-   *
-   * Answer: No, we don't.  But for every stone that we add
-   *         or remove, we must call hashdata_invert_stone(). This is
-   *         not difficult per se, but the whole board.c 
-   *         will have to be checked, and there is lots of room
-   *         for mistakes.
-   *
-   *         At the same time, profiling shows that storing the
-   *         hashdata in a stack doesn't take a lot of time, so
-   *         this is not an urgent FIXME.
-   */
-  BEGIN_CHANGE_RECORD();
-  PUSH_VALUE(board_ko_pos);
-  memcpy(&board_hash_stack[stackp], &board_hash, sizeof(board_hash));
-
-  if (board_ko_pos != NO_MOVE)
-    hashdata_invert_ko(&board_hash, board_ko_pos);
-
-  board_ko_pos = NO_MOVE;
-  
-  stackp++;
-
-  if (pos != PASS_MOVE) {
-    PUSH_VALUE(black_captured);
-    PUSH_VALUE(white_captured);
-    do_play_move(pos, color);
-  }
+  really_do_trymove(pos, color);
 
   return 1;
 }
@@ -704 +720 @@
 void
 popgo()
 {
-  stackp--;
-  
   undo_trymove();
   
-  memcpy(&board_hash, &(board_hash_stack[stackp]), sizeof(board_hash));
-
   if (sgf_dumptree) {
     char buf[100];
     int is_tryko = 0;
@@ -733 +745 @@
 }
 
 
-#if 0
-
-/* Silent version of popgo(), suitable for use if you have called
- * do_trymove() without passing through trymove() or tryko().
- */
-
-static void
-silent_popgo(void)
-{
-  stackp--;
-  undo_trymove();
-  memcpy(&board_hash, &(board_hash_stack[stackp]), sizeof(board_hash));
-}
-
-#endif
-
 /* Restore board state to the position before the last move. This is
  * accomplished by popping everything that was stored on the stacks
- * since the last BEGIN_CHANGE_RECORD().
+ * since the last BEGIN_CHANGE_RECORD(). Also stackp is decreased and
+ * board hash is restored from stack.
+ *
+ * This undoes the effects of do_trymove() or really_do_trymove() and
+ * is appropriate to call instead of popgo() if you have not passed
+ * through trymove() or tryko().
  */
 
 static void
@@ -766 +767 @@
 
   POP_MOVE();
   POP_VERTICES();
+  
+  stackp--;
+  memcpy(&board_hash, &(board_hash_stack[stackp]), sizeof(board_hash));
 }
 
 
@@ -960 +964 @@
     for (k = number_collapsed_moves; k < move_history_pointer; k++) {
       move_history_color[k - number_collapsed_moves] = move_history_color[k];
       move_history_pos[k - number_collapsed_moves] = move_history_pos[k];
+      move_history_hash[k - number_collapsed_moves] = move_history_hash[k];
     }
     move_history_pointer -= number_collapsed_moves;
 
@@ -972 +977 @@
 
   move_history_color[move_history_pointer] = color;
   move_history_pos[move_history_pointer] = pos;
+  move_history_hash[move_history_pointer] = board_hash;
+  if (board_ko_pos != NO_MOVE)
+    hashdata_invert_ko(&move_history_hash[move_history_pointer], board_ko_pos);
   move_history_pointer++;
   
   play_move_no_history(pos, color, 1);
@@ -1057 +1065 @@
 
 
 /*
- * is_legal(pos, color) determines whether the move (color) at
- * pos is legal.
+ * is_legal(pos, color) determines whether the move (color) at pos is
+ * legal. This is for internal use in the engine and always assumes
+ * that suicide is allowed and only simple ko restrictions, no
+ * superko, regardless of the rules actually used in the game.
+ *
+ * Use is_allowed_move() if you want to take alternative suicide and
+ * ko rules into account.
  */
 
 int 
@@ -1076 +1089 @@
     return 0;
 
   /* 3. The location must not be the ko point. */
-  if (pos == board_ko_pos)
+  if (pos == board_ko_pos) {
+    /*    The ko position is guaranteed to have all neighbors of the
+     *    same color, or off board. If that color is the same as the
+     *    move the ko is being filled, which is always allowed. This
+     *    could be tested with has_neighbor() but here a faster test
+     *    suffices.
+     */
     if (board[WEST(pos)] == OTHER_COLOR(color)
         || board[EAST(pos)] == OTHER_COLOR(color)) {
       return 0;
     }
+  }
 
   /* Check for stack overflow. */
   if (stackp >= MAXSTACK-2) {
@@ -1094 +1114 @@
   }
 
   /* Check for suicide. */
-  if (!allow_suicide && is_suicide(pos, color))
+  if (is_suicide(pos, color))
     return 0;
   
   return 1;
@@ -1156 +1176 @@
               || (board[EAST(pos)] == OTHER_COLOR(color))));
 }
 
+/*
+ * is_allowed_move(int pos, int color) determines whether a move is
+ * legal with respect to the suicide and ko rules in play.
+ *
+ * This function is only valid when stackp == 0 since there is no
+ * tracking of superko for trymoves.
+ */
+int
+is_allowed_move(int pos, int color)
+{
+  gg_assert(stackp == 0);
+
+  /* 1. A pass move is always legal, no matter what. */
+  if (pos == PASS_MOVE)
+    return 1;
+
+  /* 2. The move must be inside the board. */
+  ASSERT_ON_BOARD1(pos);
+
+  /* 3. The location must be empty. */
+  if (board[pos] != EMPTY) 
+    return 0;
+
+  /* 4. Simple ko repetition is only allowed if no ko rule is in use.
+   *    For superko rules this check is redundant.
+   *
+   *    The ko position is guaranteed to have all neighbors of the
+   *    same color, or off board. If that color is the same as the
+   *    move the ko is being filled, which is always allowed. This
+   *    could be tested with has_neighbor() but here a faster test
+   *    suffices.
+   */
+  if (ko_rule != NONE
+      && pos == board_ko_pos
+      && (board[WEST(pos)] == OTHER_COLOR(color)
+          || board[EAST(pos)] == OTHER_COLOR(color)))
+    return 0;
+
+  /* 5. Check for suicide. Suicide rule options:
+   *    FORBIDDEN   - No suicides allowed.
+   *    ALLOWED     - Suicide of more than one stone allowed.
+   *    ALL_ALLOWED - All suicides allowed.
+   */
+  if (is_suicide(pos, color))
+    if (suicide_rule == FORBIDDEN
+        || (suicide_rule == ALLOWED
+            && !has_neighbor(pos, color)))
+      return 0;
+
+  /* 6. Check for whole board repetitions. The superko options are
+   *    SIMPLE, NONE - No superko restrictions.
+   *    PSK          - Repetition of a previous position forbidden.
+   *    SSK          - Repetition of a previous position with the same
+   *                   player to move forbidden.
+   */
+  if (is_superko_violation(pos, color, ko_rule))
+    return 0;
+  
+  return 1;
+}
+
 /* Necessary work to set the new komaster state. */
 static void
 set_new_komaster(int new_komaster)
@@ -2938 +3019 @@
 }
 
 
+/* Return true if a move by color at pos is a superko violation
+ * according to the specified type of ko rules. This function does not
+ * detect simple ko unless it's also a superko violation.
+ *
+ * The superko detection is done by comparing board hashes from
+ * previous positions. For this to work correctly it's necessary to
+ * remove the contribution to the hash from the simple ko position.
+ * The move_history_hash array contains board hashes for previous
+ * positions, also without simple ko position contributions.
+ */
+static int
+is_superko_violation(int pos, int color, enum ko_rules type)
+{
+  Hash_data this_board_hash = board_hash;
+  Hash_data new_board_hash;
+  int k;
+
+  /* No superko violations if the ko rule is not a superko rule. */
+  if (type == NONE || type == SIMPLE)
+    return 0;
+
+  if (board_ko_pos != NO_MOVE)
+    hashdata_invert_ko(&this_board_hash, board_ko_pos);
+
+  really_do_trymove(pos, color);
+  new_board_hash = board_hash;
+  if (board_ko_pos != NO_MOVE)
+    hashdata_invert_ko(&new_board_hash, board_ko_pos);
+  undo_trymove();
+
+  /* The current position is only a problem with positional superko
+   * and a single stone suicide.
+   */
+  if (type == PSK && hashdata_is_equal(this_board_hash, new_board_hash))
+    return 1;
+
+  for (k = move_history_pointer - 1; k >= 0; k--)
+    if (hashdata_is_equal(move_history_hash[k], new_board_hash)
+        && (type == PSK
+            || move_history_color[k] == OTHER_COLOR(color)))
+      return 1;
+
+  return 0;
+}
+
 /* Returns 1 if at least one string is captured when color plays at pos.
  */
 int

engine/board.h

@@ -23 +23 @@
 #ifndef _BOARD_H_
 #define _BOARD_H_
 
+#include <stdarg.h>
+#include "config.h"
 #include "sgftree.h"
 #include "winsocket.h"
-#include "config.h"
-#include <stdarg.h>
+
+/* This type is used to store each intersection on the board.
+ *
+ * On a 486, char is best, since the time taken to push and pop
+ * becomes significant otherwise. On other platforms, an int may
+ * be better, e.g. if memcpy() is particularly fast, or if
+ * character access is very slow.
+ */
+
+typedef unsigned char Intersection;
+
+/* FIXME: This is very ugly but we can't include hash.h until we have
+ * defined Intersection. And we do need to include it before using
+ * Hash_data.
+ */
+#include "hash.h"
 
 /* local versions of absolute value, min and max */
 
@@ -117 +133 @@
 #define OTHER_COLOR(color)      (WHITE+BLACK-(color))
 #define IS_STONE(arg)           ((arg) == WHITE || (arg) == BLACK)
 
-/* This type is used to store each intersection on the board.
- *
- * On a 486, char is best, since the time taken to push and pop
- * becomes significant otherwise. On other platforms, an int may
- * be better, e.g. if memcpy() is particularly fast, or if
- * character access is very slow.
- */
-
-typedef unsigned char Intersection;
-
-
-
 /* Note that POS(-1, -1) == 0
  * DELTA() is defined so that POS(i+di, j+dj) = POS(i, j) + DELTA(di, dj).
  */
@@ -190 +194 @@
 extern int          initial_black_captured;
 extern int          move_history_color[MAX_MOVE_HISTORY];
 extern int          move_history_pos[MAX_MOVE_HISTORY];
+extern Hash_data    move_history_hash[MAX_MOVE_HISTORY];
 extern int          move_history_pointer;
 
 extern float        komi;
@@ -198 +203 @@
                     
 extern signed char  shadow[BOARDMAX];      /* reading tree shadow */
 
-extern int chinese_rules;
-extern int allow_suicide;
+enum suicide_rules {
+  FORBIDDEN,
+  ALLOWED,
+  ALL_ALLOWED
+};
+extern enum suicide_rules suicide_rule;
+
+enum ko_rules {
+  SIMPLE,
+  NONE,
+  PSK,
+  SSK
+};
+extern enum ko_rules ko_rule;
+
 
 extern int stackp;                /* stack pointer */
 extern int count_variations;      /* count (decidestring) */
@@ -221 +239 @@
   int initial_black_captured;
   int move_history_color[MAX_MOVE_HISTORY];
   int move_history_pos[MAX_MOVE_HISTORY];
+  Hash_data move_history_hash[MAX_MOVE_HISTORY];
   int move_history_pointer;
 
   float komi;
@@ -280 +299 @@
 int is_legal(int pos, int color);
 int is_suicide(int pos, int color);
 int is_illegal_ko_capture(int pos, int color);
+int is_allowed_move(int pos, int color);
 int is_ko(int pos, int color, int *ko_pos);
 int is_ko_point(int pos);
 int does_capture_something(int pos, int color);

engine/boardlib.c

@@ -39 +39 @@
 int          initial_black_captured;
 int          move_history_color[MAX_MOVE_HISTORY];
 int          move_history_pos[MAX_MOVE_HISTORY];
+Hash_data    move_history_hash[MAX_MOVE_HISTORY];
 int          move_history_pointer;
 
 float komi = 0.0;
 int handicap = 0;
 int movenum;
-int allow_suicide = 0;  /* allow opponent to make suicide moves */
+enum suicide_rules suicide_rule = FORBIDDEN;
+enum ko_rules ko_rule = SIMPLE;
 
 
 signed char shadow[BOARDMAX];

engine/genmove.c

@@ -508 +508 @@
     }
   }
 
+  /* If we somehow have managed to generate an illegal move, pass instead. */
+  if (!is_allowed_move(move, color)) {
+    TRACE("ILLEGAL MOVE GENERATED. Passing instead.\n");
+    move = PASS_MOVE;
+    *value = -1.0;
+  }
+  
   /* If no move is found then pass. */
   if (move == PASS_MOVE) {
     TRACE("I pass.\n");

engine/value_moves.c

@@ -3421 +3421 @@
 
   ko_move_target = get_biggest_owl_target(ko_move);
   
-  /* Find the ko stone. */
-  for (k = 0; k <= 3; k++) {
-    ko_stone = ko_move + delta[k];
-    if (ON_BOARD(ko_stone) && countlib(ko_stone) == 1)
-      break;
+  /* If the move is a simple ko recapture, find the ko stone. (If
+   * it's not a simple ko recapture, then the move must be a superko
+   * violation.)
+   */
+  if (is_illegal_ko_capture(ko_move, color)) {
+    for (k = 0; k <= 3; k++) {
+      ko_stone = ko_move + delta[k];
+      if (ON_BOARD(ko_stone) && countlib(ko_stone) == 1)
+        break;
+    }
+    ASSERT_ON_BOARD1(ko_stone);
   }
-  ASSERT_ON_BOARD1(ko_stone);
   
   TRACE("Reevaluating ko threats.\n");
   for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
@@ -3491 +3496 @@
     /* If there is no threat recorded, the followup value is probably
      * contributed by a pattern. We can do nothing but accept this value.
      * (although this does cause problems).
+     *
+     * FIXME: In the case of superko violation we have no ko_stone.
+     * Presumably some of the tests below should be applicable anyway.
+     * Currently we just say that any threat is ok.
      */
-    if (type == -1)
+    if (type == -1 || ko_stone == NO_MOVE)
       threat_does_work = 1;
     else {
       if (trymove(pos, color, "reevaluate_ko_threats", ko_move)) {
@@ -3686 +3695 @@
     /* If the best move is an illegal ko capture, reevaluate ko
      * threats and search again.
      */
-    if (best_value > 0.0 && is_illegal_ko_capture(best_move, color)) {
+    if (best_value > 0.0
+        && (is_illegal_ko_capture(best_move, color)
+            || !is_allowed_move(best_move, color))) {
       TRACE("Move at %1m would be an illegal ko capture.\n", best_move);
       reevaluate_ko_threats(best_move, color, best_value);
       redistribute_points();

interface/main.c

@@ -143 +143 @@
       OPT_OWL_THREATS,
       OPT_NO_OWL_THREATS,
       OPT_JAPANESE_RULES,
+      OPT_FORBID_SUICIDE,
       OPT_ALLOW_SUICIDE,
+      OPT_ALLOW_ALL_SUICIDE,
+      OPT_SIMPLE_KO,
+      OPT_NO_KO,
+      OPT_POSITIONAL_SUPERKO,
+      OPT_SITUATIONAL_SUPERKO,
       OPT_CAPTURE_ALL_DEAD,
       OPT_PLAY_OUT_AFTERMATH,
       OPT_MIRROR,
@@ -249 +255 @@
   {"standard-connections",  no_argument, 0, OPT_STANDARD_CONNECTIONS},
   {"standard-semeai", no_argument,      0, OPT_STANDARD_SEMEAI},
   {"alternate-connections",  no_argument, 0, OPT_ALTERNATE_CONNECTIONS},
-  {"with-break-in",     no_argument, 0, OPT_WITH_BREAK_IN},
-  {"without-break-in",  no_argument, 0, OPT_WITHOUT_BREAK_IN},
-  {"cosmic-gnugo",   no_argument, 0, OPT_COSMIC_GNUGO},
-  {"no-cosmic-gnugo",   no_argument, 0, OPT_NO_COSMIC_GNUGO},
-  {"large-scale",    no_argument, 0, OPT_LARGE_SCALE},
-  {"no-large-scale",    no_argument, 0, OPT_NO_LARGE_SCALE},
-  {"options",        no_argument, 0, OPT_OPTIONS},
-  {"allow-suicide",  no_argument,       0, OPT_ALLOW_SUICIDE},
-  {"capture-all-dead",   no_argument,   0, OPT_CAPTURE_ALL_DEAD},
-  {"play-out-aftermath", no_argument,   0, OPT_PLAY_OUT_AFTERMATH},
+  {"with-break-in",        no_argument, 0, OPT_WITH_BREAK_IN},
+  {"without-break-in",     no_argument, 0, OPT_WITHOUT_BREAK_IN},
+  {"cosmic-gnugo",         no_argument, 0, OPT_COSMIC_GNUGO},
+  {"no-cosmic-gnugo",      no_argument, 0, OPT_NO_COSMIC_GNUGO},
+  {"large-scale",          no_argument, 0, OPT_LARGE_SCALE},
+  {"no-large-scale",       no_argument, 0, OPT_NO_LARGE_SCALE},
+  {"options",              no_argument, 0, OPT_OPTIONS},
+  {"forbid-suicide",       no_argument, 0, OPT_FORBID_SUICIDE},
+  {"allow-suicide",        no_argument, 0, OPT_ALLOW_SUICIDE},
+  {"allow-all-suicide",    no_argument, 0, OPT_ALLOW_ALL_SUICIDE},
+  {"simple-ko",            no_argument, 0, OPT_SIMPLE_KO},
+  {"no-ko",                no_argument, 0, OPT_NO_KO},
+  {"positional-superko",   no_argument, 0, OPT_POSITIONAL_SUPERKO},
+  {"situational-superko",  no_argument, 0, OPT_SITUATIONAL_SUPERKO},
+  {"capture-all-dead",     no_argument, 0, OPT_CAPTURE_ALL_DEAD},
+  {"play-out-aftermath",   no_argument, 0, OPT_PLAY_OUT_AFTERMATH},
   {"cache-size",     required_argument, 0, 'M'},
   {"worms",          no_argument,       0, 'w'},
   {"moyo",           required_argument, 0, 'm'},
@@ -583 +595 @@
         large_scale = 0;
         break;
 
+      case OPT_FORBID_SUICIDE:
+        suicide_rule = FORBIDDEN;
+        break;
+
       case OPT_ALLOW_SUICIDE:
-        allow_suicide = 1;
+        suicide_rule = ALLOWED;
+        break;
+
+      case OPT_ALLOW_ALL_SUICIDE:
+        suicide_rule = ALL_ALLOWED;
+        break;
+
+      case OPT_SIMPLE_KO:
+        ko_rule = SIMPLE;
+        break;
+
+      case OPT_NO_KO:
+        ko_rule = NONE;
+        break;
+
+      case OPT_POSITIONAL_SUPERKO:
+        ko_rule = PSK;
+        break;
+
+      case OPT_SITUATIONAL_SUPERKO:
+        ko_rule = SSK;
         break;
 
       case OPT_CAPTURE_ALL_DEAD:
@@ -1441 +1477 @@
 \n\
    --japanese-rules     (default)\n\
    --chinese-rules\n\
-   --allow-suicide\n\
+   --forbid-suicide      Forbid suicide. (default)\n\
+   --allow-suicide       Allow suicide except single-stone suicide.\n\
+   --allow-all-suicide   Allow all suicide moves.\n\
+   --simple-ko           Forbid simple ko recapture. (default)\n\
+   --no-ko               Allow any ko recapture.\n\
+   --positional-superko  Positional superko restrictions.\n\
+   --situational-superko Situational superko restrictions.\n\
 \n\
    --play-out-aftermath\n\
    --capture-all-dead\n\

interface/play_ascii.c

@@ -520 +520 @@
     return 0;
   }
   
-  if (!is_legal(move, gameinfo->to_move)) {
+  if (!is_allowed_move(move, gameinfo->to_move)) {
     printf("\nIllegal move: %s", command);
     return 0;
   }

interface/play_gtp.c

@@ -605 +605 @@
   else if (!gtp_decode_coord(s, &i, &j))
     return gtp_failure("invalid coordinate");
 
-  if (!is_legal(POS(i, j), BLACK))
+  if (!is_allowed_move(POS(i, j), BLACK))
     return gtp_failure("illegal move");
 
   gnugo_play_move(POS(i, j), BLACK);
@@ -636 +636 @@
   else if (!gtp_decode_coord(s, &i, &j))
     return gtp_failure("invalid coordinate");