Ticket #150: MonteGNU.diff

engine/genmove.c

@@ -30 +30 @@
 #include "sgftree.h"
 #include "gg_utils.h"
 
+
+static int
+monte_carlo_genmove(int color, int allowed_moves[BOARDMAX],
+                    float *value, int *resign)
+{
+  int pos;
+  int best_move = PASS_MOVE;
+  int best_uct_move = PASS_MOVE;
+  int unconditional_territory_black[BOARDMAX];
+  int unconditional_territory_white[BOARDMAX];
+  int forbidden_move[BOARDMAX];
+  float move_values[BOARDMAX];
+  int move_frequencies[BOARDMAX];
+
+  memset(move_values, 0, sizeof(move_values));
+  memset(move_frequencies, 0, sizeof(move_frequencies));
+  
+  if (0) {
+    simple_showboard(stderr);
+    gprintf("\n");
+  }
+
+  if (resign)
+    *resign = 0;
+  
+  unconditional_life(unconditional_territory_black, BLACK);
+  unconditional_life(unconditional_territory_white, WHITE);
+
+  for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+    if (!ON_BOARD(pos))
+      continue;
+    else if (unconditional_territory_black[pos])
+      forbidden_move[pos] = BLACK;
+    else if (unconditional_territory_white[pos])
+      forbidden_move[pos] = WHITE;
+    else
+      forbidden_move[pos] = 0;
+
+  /* FIXME: Add configuration option. */
+#if 1
+  uct_genmove(color, &best_uct_move, forbidden_move, allowed_moves,
+              10000 * (get_level() + 1), move_values, move_frequencies);
+#else
+  uct_genmove(color, &best_uct_move, forbidden_move, allowed_moves,
+              2000, move_values, move_frequencies);
+#endif
+  best_move = best_uct_move;
+#if 0
+  /* FIXME: Don't hardcode 0.75 and 0.4. */
+  if (move_values[best_move] > 0.75) {
+    float best_value = 0.0;
+    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+      if (ON_BOARD(pos)
+          && move_values[pos] > 0.75
+          && potential_moves[pos] > best_value) {
+        best_move = pos;
+        best_value = potential_moves[pos];
+      }
+    }
+  }
+  else if (move_values[best_move] < 0.40) {
+    float best_value = 0.0;
+    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+      if (ON_BOARD(pos)
+          && (!allowed_moves || allowed_moves[pos])
+          && potential_moves[pos] > best_value) {
+        best_move = pos;
+        best_value = potential_moves[pos];
+      }
+    }
+  }
+#elif 1
+  if (1) {
+    float best_value = 0.0;
+    int frequency_cutoff = move_frequencies[best_uct_move] / 2;
+    int frequency_cutoff2 = move_frequencies[best_uct_move] / 10;
+    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+      if (ON_BOARD(pos)
+          && (move_frequencies[pos] > frequency_cutoff
+              || (move_values[pos] > 0.9
+                  && move_frequencies[pos] > frequency_cutoff2)
+              || move_values[best_uct_move] < 0.1)
+          && (!allowed_moves || allowed_moves[pos])
+          && potential_moves[pos] > best_value) {
+        best_move = pos;
+        best_value = potential_moves[pos];
+      }
+    }
+  }
+#else
+  if (1) {
+    float best_value = 0.0;
+    for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+      if (ON_BOARD(pos)
+          && (!allowed_moves || allowed_moves[pos])
+          && potential_moves[pos] + 10.0 * move_values[pos] > best_value) {
+        best_move = pos;
+        best_value = potential_moves[pos] + 10.0 * move_values[pos];
+      }
+    }
+  }
+#endif
+
+  unconditionally_meaningless_move(best_move, color, &best_move);
+
+  *value = 1.0;
+  
+  return best_move;
+}
+
 /* Return one if x doesn't equal position_number and 0 otherwise.
  * After using this macro x will always have the value
  * position_number.
@@ -475 +585 @@
                 NO_MOVE, 1.0);
   }
 
+  if (move != PASS_MOVE && (*value < 75.0 || *value > 75.01) && !doing_scoring) {
+    int allowed_moves2[BOARDMAX];
+    int num_allowed_moves2 = 0;
+    int pos;
+    for (pos = BOARDMIN; pos < BOARDMAX; pos++)
+      if (ON_BOARD(pos)
+          && (!allowed_moves || allowed_moves[pos])
+#if 0
+          && potential_moves[pos] > (*value * 3 / 4)
+#endif
+          && is_allowed_move(pos, color)) {
+        allowed_moves2[pos] = 1;
+        num_allowed_moves2++;
+      }
+      else
+        allowed_moves2[pos] = 0;
+    
+    if (num_allowed_moves2 > 1)
+      move = monte_carlo_genmove(color, allowed_moves2, value, resign);
+  }
+  
   /* If still no move, fill a remaining liberty. This should pick up
    * all missing dame points.
    */

engine/liberty.h

@@ -492 +492 @@
                       int allowed_moves[BOARDMAX]);
 enum dragon_status aftermath_final_status(int color, int pos);
 
+void uct_genmove(int color, int *move, int *forbidden_moves,
+                 int *allowed_moves, int nodes, float *move_values,
+                 int *move_frequencies);
+
+
 int owl_attack(int target, int *attack_point, int *certain, int *kworm);
 int owl_defend(int target, int *defense_point, int *certain, int *kworm);
 int owl_threaten_attack(int target, int *attack1, int *attack2);

engine/montecarlo.c

@@ +1 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
+ * 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, 2006,         *
+ * and 2007 by the Free Software Foundation.                         *
+ *                                                                   *
+ * This program is free software; you can redistribute it and/or     *
+ * modify it under the terms of the GNU General Public License as    *
+ * published by the Free Software Foundation - version 2             *
+ *                                                                   *
+ * This program is distributed in the hope that it will be useful,   *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of    *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the     *
+ * GNU General Public License in file COPYING for more details.      *
+ *                                                                   *
+ * You should have received a copy of the GNU General Public         *
+ * License along with this program; if not, write to the Free        *
+ * Software Foundation, Inc., 51 Franklin Street, Fifth Floor,       *
+ * Boston, MA 02111, USA.                                            *
+\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include "gnugo.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "liberty.h"
+#include "sgftree.h"
+#include "gg_utils.h"
+
+#include "random.h"
+#include <math.h>
+
+/* Special board code for Monte Carlo simulations.
+ *
+ * A liberty edge is the combination of the position of the liberty
+ * and the direction to a string given by the index into the delta[]
+ * array. A liberty edge at lib with corresponding string in direction
+ * delta[dir] is encoded as (lib << 2 | dir).
+ *
+ * The stones of a string are linked in a cyclic list through the
+ * next_stone field, just like the global board does.
+ *
+ * Likewise the liberty edges corresponding to each string are
+ * connected in a doubly linked cyclic list through the
+ * previous_liberty_edge and next_liberty_edge fields.
+ *
+ * The reference stone has to be the same for every stone in a string
+ * but it doesn't have to be a predictable one, in contrast to the
+ * origin in the global board. The reference stone is the only one
+ * which is guaranteed to have a valid pointer to the "first" liberty
+ * edge (just an arbitrary element in the circular list).
+ */
+
+
+struct mc_board {
+  Intersection board[BOARDSIZE];
+  int board_ko_pos;
+  int reference_stone[BOARDMAX];
+  int next_stone[BOARDMAX];
+  int first_liberty_edge[BOARDMAX];
+  int previous_liberty_edge[4 * BOARDMAX];
+  int next_liberty_edge[4 * BOARDMAX];
+  Hash_data hash;
+};
+
+#define MC_ON_BOARD(pos) (mc->board[pos] != GRAY)
+
+/* Add a liberty edge for a string at pos with liberty at lib and
+ * direction dir.
+ */
+static void
+mc_add_liberty_edge(struct mc_board *mc, int pos, int lib, int dir)
+{
+  int this_liberty_edge = (lib << 2) | dir;
+  int reference = mc->reference_stone[pos];
+  int first_liberty_edge = mc->first_liberty_edge[reference];
+
+  gg_assert(lib + delta[dir] == pos);
+  
+  if (first_liberty_edge) {
+    int second_liberty_edge = mc->next_liberty_edge[first_liberty_edge];
+    mc->previous_liberty_edge[this_liberty_edge] = first_liberty_edge;
+    mc->next_liberty_edge[this_liberty_edge] = second_liberty_edge;
+    mc->next_liberty_edge[first_liberty_edge] = this_liberty_edge;
+    mc->previous_liberty_edge[second_liberty_edge] = this_liberty_edge;
+  }
+  else {
+    mc->first_liberty_edge[reference] = this_liberty_edge;
+    mc->next_liberty_edge[this_liberty_edge] = this_liberty_edge;
+    mc->previous_liberty_edge[this_liberty_edge] = this_liberty_edge;
+  }
+}
+
+
+/* Remove a liberty edge for a string at pos with liberty at lib and
+ * direction dir.
+ */
+static int
+mc_remove_liberty_edge(struct mc_board *mc, int pos, int lib, int dir)
+{
+  int reference = mc->reference_stone[pos];
+  int this_liberty_edge = (lib << 2) | dir;
+  int next = mc->next_liberty_edge[this_liberty_edge];
+  int previous = mc->previous_liberty_edge[this_liberty_edge];
+  
+  gg_assert(lib + delta[dir] == pos);
+  
+  if (next == this_liberty_edge) {
+    mc->first_liberty_edge[reference] = 0;
+    return 0;
+  }
+
+  mc->next_liberty_edge[previous] = next;
+  mc->previous_liberty_edge[next] = previous;
+  if (mc->first_liberty_edge[reference] == this_liberty_edge)
+    mc->first_liberty_edge[reference] = next;
+
+  return next;
+}
+
+
+/* Join the strings at str1 and str2. It is assumed that str1 is a
+ * newly placed stone (possibly already joined with other strings) and
+ * that the liberty edge corresponding to the liberty at the newly
+ * placed stone has not yet been removed.
+ */
+static void
+mc_join_strings(struct mc_board *mc, int str1, int str2)
+{
+  int reference = mc->reference_stone[str2];
+  int liberty_edge2 = mc->first_liberty_edge[reference];
+  int liberty_edge1 = mc->first_liberty_edge[mc->reference_stone[str1]];
+  int next1;
+  int next2;
+  int pos = str1;
+
+  /* Update the reference stone for str1. */
+  do {
+    mc->reference_stone[pos] = reference;
+    pos = mc->next_stone[pos];
+  } while (pos != str1);
+
+  /* Switch next_stone pointers to join the strings. */
+  next1 = mc->next_stone[str1];
+  mc->next_stone[str1] = mc->next_stone[str2];
+  mc->next_stone[str2] = next1;
+
+  /* Join the circular liberty_edge structures. We know that str2
+   * still has a liberty listed at the newly added stone so
+   * liberty_edge2 is guaranteed to be non-zero.
+   */
+  if (liberty_edge1 != 0) {
+    next1 = mc->next_liberty_edge[liberty_edge1];
+    next2 = mc->next_liberty_edge[liberty_edge2];
+    mc->next_liberty_edge[liberty_edge1] = next2;
+    mc->next_liberty_edge[liberty_edge2] = next1;
+    mc->previous_liberty_edge[next1] = liberty_edge2;
+    mc->previous_liberty_edge[next2] = liberty_edge1;
+  }
+}
+
+
+/* Remove the string at str from the board. */
+static int
+mc_remove_string(struct mc_board *mc, int str)
+{
+  int color = mc->board[str];
+  int other = OTHER_COLOR(color);
+  int pos = str;
+  int num_removed_stones = 0;
+  int k;
+  
+  do {
+    for (k = 0; k < 4; k++)
+      if (mc->board[pos + delta[k]] == other)
+        mc_add_liberty_edge(mc, pos + delta[k], pos, k);
+    mc->board[pos] = EMPTY;
+    hashdata_invert_stone(&(mc->hash), pos, color);
+    num_removed_stones++;
+    pos = mc->next_stone[pos];
+  } while (pos != str);
+
+  return num_removed_stones;
+}
+
+
+/* Initialize a Monte Carlo board struct from the global board. */
+static void
+mc_init_board_from_global_board(struct mc_board *mc)
+{
+  int stones[BOARDMAX];
+  int num_stones;
+  int pos;
+  int k;
+  int r;
+  
+  memcpy(mc->board, board, sizeof(mc->board));
+  mc->board_ko_pos = board_ko_pos;
+  mc->hash = board_hash;
+
+  memset(mc->next_stone, 0, sizeof(mc->next_stone));
+  for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
+    if (IS_STONE(board[pos]) && mc->next_stone[pos] == 0) {
+      num_stones = findstones(pos, BOARDMAX, stones);
+      mc->first_liberty_edge[pos] = 0;
+      for (r = 0; r < num_stones; r++) {
+        mc->next_stone[stones[r]] = stones[(r + 1) % num_stones];
+        mc->reference_stone[stones[r]] = pos;
+        for (k = 0; k < 4; k++) {
+          if (board[stones[r] + delta[k]] == EMPTY)
+            mc_add_liberty_edge(mc, stones[r], stones[r] + delta[k],
+                                (k + 2) % 4);
+        }
+      }
+    }
+  }
+}
+
+
+static void
+mc_check_consistency_with_global_board(struct mc_board *mc)
+{
+  int pos;
+
+  ASSERT1(board_ko_pos == mc->board_ko_pos, mc->board_ko_pos);
+  for (pos = 0; pos < BOARDSIZE; pos++) {
+    ASSERT1(board[pos] == mc->board[pos], pos);
+    if (IS_STONE(board[pos])) {
+      ASSERT1(same_string(pos, mc->reference_stone[pos]), pos);
+      if (find_origin(pos) == pos) {
+        int reference = mc->reference_stone[pos];
+        int pos2 = pos;
+        int num_stones = 0;
+        int first_liberty_edge;
+        int liberty_edge;
+        int num_liberty_edges = 0;
+        int k;
+        int ml[4 * BOARDMAX];
+        memset(ml, 0, sizeof(ml));
+        
+        do {
+          ASSERT1(mc->reference_stone[pos2] == reference, pos2);
+          ASSERT1(num_stones < countstones(pos), pos);
+          num_stones++;
+          for (k = 0; k < 4; k++)
+            if (board[pos2 + delta[k]] == EMPTY) {
+              ml[(pos2 + delta[k]) << 2 | (k + 2) % 4] = 1;
+              num_liberty_edges++;
+            }
+          pos2 = mc->next_stone[pos2];
+        } while (pos2 != pos);
+        ASSERT1(num_stones == countstones(pos), pos);
+
+        first_liberty_edge = mc->first_liberty_edge[reference];
+        liberty_edge = first_liberty_edge;
+        do {
+          int previous = mc->previous_liberty_edge[liberty_edge];
+          int next = mc->next_liberty_edge[liberty_edge];
+          ASSERT1(ml[liberty_edge] == 1, pos);
+          ml[liberty_edge] = 0;
+          num_liberty_edges--;
+          ASSERT1(mc->next_liberty_edge[previous] == liberty_edge, pos);
+          ASSERT1(mc->previous_liberty_edge[next] == liberty_edge, pos);
+          ASSERT1(liberty_of_string(liberty_edge >> 2, pos), pos);
+          liberty_edge = mc->next_liberty_edge[liberty_edge];
+        } while (liberty_edge != first_liberty_edge);
+        ASSERT1(num_liberty_edges == 0, pos);
+      }
+    }
+  }
+}
+
+
+/* Write the Monte Carlo board to outfile.
+ */
+static void
+mc_showboard(struct mc_board *mc, FILE *outfile)
+{
+  int i, j;
+
+  draw_letter_coordinates(outfile);
+  
+  for (i = 0; i < board_size; i++) {
+    fprintf(outfile, "\n%2d", board_size - i);
+    
+    for (j = 0; j < board_size; j++) {
+      if (mc->board[POS(i, j)] == EMPTY)
+        fprintf(outfile, " %c", is_hoshi_point(i, j) ? '+' : '.');
+      else
+        fprintf(outfile, " %c", mc->board[POS(i, j)] == BLACK ? 'X' : 'O');
+    }
+  }
+  
+  fprintf(outfile, "\n");
+  draw_letter_coordinates(outfile);
+}
+
+
+/* Count the number of stones in the string at str. Stop counting if
+ * maxstones is reached.
+ */
+static int
+mc_countstones(struct mc_board *mc, int str, int maxstones)
+{
+  int stone = str;
+  int num_stones = 0;
+  do {
+    num_stones++;
+    stone = mc->next_stone[stone];
+  } while (stone != str && num_stones < maxstones);
+
+  return num_stones;
+}
+
+/* Is a move at pos by color suicide? */
+static int
+mc_is_suicide(struct mc_board *mc, int pos, int color)
+{
+  int k;
+  
+  if (mc->board[SOUTH(pos)] == EMPTY
+      || mc->board[WEST(pos)] == EMPTY
+      || mc->board[NORTH(pos)] == EMPTY
+      || mc->board[EAST(pos)] == EMPTY)
+    return 0;
+
+  for (k = 0; k < 4; k++) {
+    int first_liberty_edge;
+    int liberty_edge;
+    int additional_liberty = 0;
+    if (!ON_BOARD(pos + delta[k]))
+      continue;
+
+    first_liberty_edge = (pos << 2) | k;
+    liberty_edge = mc->next_liberty_edge[first_liberty_edge];
+    while (liberty_edge != first_liberty_edge) {
+      if ((liberty_edge >> 2) != pos) {
+        additional_liberty = 1;
+        break;
+      }
+      liberty_edge = mc->next_liberty_edge[liberty_edge];
+    }
+
+    if ((mc->board[pos + delta[k]] != color) ^ additional_liberty)
+      return 0;
+  }
+
+  return 1;
+}
+
+
+/* Is a move at pos by color legal? */
+static int
+mc_is_legal(struct mc_board *mc, int pos, int color)
+{
+  if (pos == PASS_MOVE)
+    return 1;
+
+  if (mc->board[pos] != EMPTY)
+    return 0;
+
+  if (pos == mc->board_ko_pos) {
+    if (mc->board[WEST(pos)] == OTHER_COLOR(color)
+        || mc->board[EAST(pos)] == OTHER_COLOR(color)) {
+      return 0;
+    }
+  }
+
+  return !mc_is_suicide(mc, pos, color);
+}
+
+
+/* Is the string at str in atari? Always place one liberty of the
+ * string in lib, unless it's a null pointer.
+ */
+static int
+mc_is_in_atari(struct mc_board *mc, int str, int *lib)
+{
+  int reference = mc->reference_stone[str];
+  int first_liberty_edge = mc->first_liberty_edge[reference];
+  int liberty = first_liberty_edge >> 2;
+  int liberty_edge = mc->next_liberty_edge[first_liberty_edge];
+  ASSERT1(IS_STONE(mc->board[str]), str);
+  if (lib)
+    *lib = liberty;
+  while (liberty_edge != first_liberty_edge) {
+    if ((liberty_edge >> 2) != liberty)
+      return 0;
+    liberty_edge = mc->next_liberty_edge[liberty_edge];
+  }
+
+  return 1;
+}
+
+
+/* Does the string at str have exactly two liberties? Place those in
+ * lib[0] and lib[1] unless lib is a NULL pointer. 
+ */
+static int
+mc_has_two_liberties(struct mc_board *mc, int str, int *lib)
+{
+  int reference = mc->reference_stone[str];
+  int first_liberty_edge = mc->first_liberty_edge[reference];
+  int first_liberty = first_liberty_edge >> 2;
+  int liberty_edge = mc->next_liberty_edge[first_liberty_edge];
+  int second_liberty;
+  ASSERT1(IS_STONE(mc->board[str]), str);
+  if (lib)
+    lib[0] = first_liberty;
+  while (liberty_edge != first_liberty_edge) {
+    if ((liberty_edge >> 2) != first_liberty) {
+      second_liberty = liberty_edge >> 2;
+      if (lib)
+        lib[1] = second_liberty;
+      while (liberty_edge != first_liberty_edge) {
+        if ((liberty_edge >> 2) != first_liberty
+            && (liberty_edge >> 2) != second_liberty)
+          return 0;
+        liberty_edge = mc->next_liberty_edge[liberty_edge];
+      }
+      return 1;
+    }
+    liberty_edge = mc->next_liberty_edge[liberty_edge];
+  }
+
+  return 0;
+}
+
+
+/* Is a move at pos by color a self atari? */
+static int
+mc_is_self_atari(struct mc_board *mc, int pos, int color)
+{
+  int k;
+  int captured = NO_MOVE;
+  int liberty = NO_MOVE;
+  int reference;
+  int other;
+
+  /* Quick test which is often effective. */
+  if (((mc->board[SOUTH(pos)] == EMPTY)
+       + (mc->board[WEST(pos)] == EMPTY)
+       + (mc->board[NORTH(pos)] == EMPTY)
+       + (mc->board[EAST(pos)] == EMPTY)) > 1)
+    return 0;
+
+  /* Otherwise look closer. */
+  for (k = 0; k < 4; k++) {
+    int first_liberty_edge;
+    int liberty_edge;
+    int additional_liberty = 0;
+    int pos2 = pos + delta[k];
+    if (mc->board[pos2] == EMPTY) {
+      if (pos2 != liberty) {
+        if (liberty != NO_MOVE)
+          return 0;
+        else
+          liberty = pos2;
+      }
+    }
+    else if (IS_STONE(mc->board[pos2])) {
+      first_liberty_edge = (pos << 2) | k;
+      liberty_edge = mc->next_liberty_edge[first_liberty_edge];
+      while (liberty_edge != first_liberty_edge) {
+        int lib = liberty_edge >> 2;
+        if (lib != pos) {
+          additional_liberty = 1;
+          if (mc->board[pos2] == color) {
+            if (lib != liberty) {
+              if (liberty != NO_MOVE)
+                return 0;
+              else
+                liberty = lib;
+            }
+          }
+          else
+            break;
+        }
+        liberty_edge = mc->next_liberty_edge[liberty_edge];
+      }
+
+      if (mc->board[pos2] != color && additional_liberty == 0) {
+        captured = pos2;
+        if (pos2 != liberty) {
+          if (liberty != NO_MOVE)
+            return 0;
+          else
+            liberty = pos2;
+        }
+      }
+    }
+  }
+
+  if (liberty == NO_MOVE || captured == NO_MOVE)
+    return 1;
+
+  /* Now only the difficult case remains where there was no adjacent
+   * empty stone, no adjacent friendly stone with an extra liberty,
+   * and exactly one neighbor was captured. Then the question is
+   * whether the capture produced a second liberty elsewhere.
+   */
+  reference = mc->reference_stone[captured];
+  other = OTHER_COLOR(color);
+  for (k = 0; k < 4; k++) {
+    if (board[pos + delta[k]] == color) {
+      int stone = pos + delta[k];
+      do {
+        int m;
+        for (m = 0; m < 4; m++) {
+          int pos2 = stone + delta[m];
+          if (board[pos2] == other
+              && pos2 != captured
+              && mc->reference_stone[pos2] == reference)
+            return 0;
+        }
+        stone = mc->next_stone[stone];
+      } while (stone != pos + delta[k]);
+    }
+  }
+
+  return 1;
+}
+
+
+/* Does the string at str have a neighbor in atari? If so, return a
+ * move to capture a neighbor. Do not return a ko recapture.
+ * FIXME: Modify this to optionally return all such moves.
+ * FIXME: Does it pay off the keep a string mark array in the mc_board
+ *        struct?
+ */
+static int
+mc_break_chain(struct mc_board *mc, int str, int *move)
+{
+  unsigned char found_neighbors[BOARDMAX];
+  int pos = str;
+  int other = OTHER_COLOR(mc->board[str]);
+  ASSERT1(IS_STONE(mc->board[str]), str);
+  memset(found_neighbors, 0, sizeof(found_neighbors));
+  do {
+    int k;
+    for (k = 0; k < 4; k++) {
+      if (mc->board[pos + delta[k]] == other) {
+        int reference = mc->reference_stone[pos + delta[k]];
+        if (!found_neighbors[reference]) {
+          found_neighbors[reference] = 1;
+          if (mc_is_in_atari(mc, pos + delta[k], move)
+              && *move != mc->board_ko_pos)
+            return 1;
+        }
+      }
+    }
+    pos = mc->next_stone[pos];
+  } while (pos != str);
+
+  *move = NO_MOVE;
+  return 0;
+}
+
+
+/* Play the move at pos by color. */
+static int
+mc_play_move(struct mc_board *mc, int pos, int color)
+{
+  int k;
+  int captured_stones = 0;
+  int num_direct_liberties = 0;
+  
+  if (pos == PASS_MOVE) {
+    if (mc->board_ko_pos != NO_MOVE)
+      hashdata_invert_ko(&mc->hash, mc->board_ko_pos);
+    mc->board_ko_pos = NO_MOVE;
+    return 1;
+  }
+  
+  /* The move must not be the ko point. */
+  if (pos == mc->board_ko_pos) {
+    if (mc->board[WEST(pos)] == OTHER_COLOR(color)
+        || mc->board[EAST(pos)] == OTHER_COLOR(color)) {
+      return 0;
+    }
+  }
+  
+  /* Test for suicide. */
+  if (mc_is_suicide(mc, pos, color))
+    return 0;
+
+  if (mc->board_ko_pos != NO_MOVE)
+    hashdata_invert_ko(&mc->hash, mc->board_ko_pos);
+  mc->board_ko_pos = NO_MOVE;
+
+  ASSERT1(mc->board[pos] == EMPTY, pos);
+  mc->board[pos] = color;
+  hashdata_invert_stone(&mc->hash, pos, color);
+  mc->next_stone[pos] = pos;
+  mc->reference_stone[pos] = pos;
+  mc->first_liberty_edge[pos] = 0;
+
+  for (k = 0; k < 4; k++) {
+    int pos2 = pos + delta[k];
+    if (mc->board[pos2] == EMPTY) {
+      mc_add_liberty_edge(mc, pos, pos2, (k + 2) % 4);
+      num_direct_liberties++;
+    }
+  }
+  
+  for (k = 0; k < 4; k++) {
+    int pos2 = pos + delta[k];
+    if (mc->board[pos2] == OTHER_COLOR(color)) {
+      if (mc_remove_liberty_edge(mc, pos2, pos, k) == 0)
+        captured_stones += mc_remove_string(mc, pos2);
+    }
+    else if (mc->board[pos2] == color) {
+      if (mc->reference_stone[pos] != mc->reference_stone[pos2])
+        mc_join_strings(mc, pos, pos2);
+      mc_remove_liberty_edge(mc, pos2, pos, k);
+    }
+  }
+
+  if (captured_stones == 1
+      && mc->next_stone[pos] == pos
+      && num_direct_liberties == 0) {
+    mc->board_ko_pos = mc->first_liberty_edge[pos] >> 2;
+    hashdata_invert_ko(&mc->hash, mc->board_ko_pos);
+  }
+  
+  return 1;
+}
+
+
+/***************************************************/
+
+#define ASSERT_LEGAL 1
+
+struct mc_game {
+  struct mc_board mc;
+  unsigned char settled[BOARDMAX];
+  int color_to_move;
+  int last_move;
+  int consecutive_passes;
+  int consecutive_ko_captures;
+  int depth;
+};
+
+/* Generate a random move. */
+static int
+mc_generate_random_move(struct mc_game *game, int *global_move_ordering,
+                        int num_ordered_moves, int only_reactive_moves)
+{
+  struct mc_board *mc = &game->mc;
+  int last_move = game->last_move;
+  int color = game->color_to_move;
+  int depth = game->depth;
+  
+  int moves[MAX_BOARD * MAX_BOARD];
+  int num_moves = 0;
+  int pos;
+  int k;
+  int offset;
+  int move;
+  int liberties[2];
+
+  /* If we get this deep we are almost certainly playing triple ko
+   * without alternative options, so just give up and score as is.
+   *
+   * FIXME: Handle this in some proper way.
+   */
+  if (depth > 600) {
+    fprintf(stderr, "Reached 600 iterations.\n");
+    mc_showboard(mc, stderr);
+    return PASS_MOVE;
+  }
+