rubykon 0.3.0

data/lib/mcts.rb

@@ -0,0 +1,11 @@
+require_relative 'mcts/node'
+require_relative 'mcts/root'
+require_relative 'mcts/playout'
+require_relative 'mcts/mcts'
+
+module MCTS
+  UCT_BIAS_FACTOR = 2
+  DEFAULT_PLAYOUTS = 1_000
+end
+
+

data/lib/mcts/examples/double_step.rb

@@ -0,0 +1,68 @@
+module MCTS
+  module Examples
+    class DoubleStep
+
+      FINAL_POSITION = 6
+      MAX_STEP = 2
+
+      attr_reader :positions
+
+      def initialize(positions = init_positions, n = 0)
+        @positions = positions
+        @move_count = n
+      end
+
+      def finished?
+        @positions.any? {|_color, position| position >= FINAL_POSITION }
+      end
+
+      def generate_move
+        rand(MAX_STEP) + 1
+      end
+
+      def set_move(move)
+        steps = move
+        @positions[next_turn_color] += steps
+        @move_count += 1
+      end
+
+      def dup
+        self.class.new @positions.dup, @move_count
+      end
+
+      def won?(color)
+        fail "Game not finished" unless finished?
+        @positions[color] > @positions[other_color(color)]
+      end
+
+      def all_valid_moves
+        if finished?
+          []
+        else
+          [1, 2]
+        end
+      end
+
+      def last_turn_color
+        @move_count.odd? ? :black : :white
+      end
+
+      private
+      def next_turn_color
+        @move_count.even? ? :black : :white
+      end
+
+      def init_positions
+        {black: 0, white: 0}
+      end
+
+      def other_color(color)
+        if color == :black
+          :white
+        else
+          :black
+        end
+      end
+    end
+  end
+end

data/lib/mcts/mcts.rb

@@ -0,0 +1,13 @@
+module MCTS
+  class MCTS
+    def start(game_state, playouts = DEFAULT_PLAYOUTS)
+      root = Root.new(game_state)
+
+      playouts.times do |i|
+        root.explore_tree
+      end
+      root
+    end
+  end
+end
+

data/lib/mcts/node.rb

@@ -0,0 +1,88 @@
+module MCTS
+  class Node
+    attr_reader :parent,  :move, :wins, :visits, :children, :game_state
+
+    def initialize(game_state, move, parent)
+      @parent        = parent
+      @game_state    = game_state
+      @move          = move
+      @wins          = 0.0
+      @visits        = 0
+      @children      = []
+      @untried_moves = game_state.all_valid_moves
+      @leaf          = game_state.finished? || @untried_moves.empty?
+    end
+
+    def uct_value
+      win_percentage + UCT_BIAS_FACTOR * Math.sqrt(Math.log(parent.visits)/@visits)
+    end
+
+    def win_percentage
+      @wins/@visits
+    end
+
+    def root?
+      false
+    end
+
+    def leaf?
+      @leaf
+    end
+
+    def uct_select_child
+      children.max_by &:uct_value
+    end
+
+    # maybe get a maximum depth or soemthing in
+    def expand
+      move = @untried_moves.pop
+      create_child(move)
+    end
+
+    def rollout
+      playout = Playout.new(@game_state)
+      playout.play
+    end
+
+    def won
+      @visits += 1
+      @wins += 1
+    end
+
+    def lost
+      @visits += 1
+    end
+
+    def backpropagate(won)
+      node = self
+      node.update_won won
+      until node.root? do
+        won = !won # switching players perspective
+        node = node.parent
+        node.update_won(won)
+      end
+    end
+
+    def untried_moves?
+      !@untried_moves.empty?
+    end
+
+    def update_won(won)
+      if won
+        self.won
+      else
+        self.lost
+      end
+    end
+
+    private
+
+    def create_child(move)
+      game_state = @game_state.dup
+      game_state.set_move(move)
+      child = Node.new game_state, move, self
+      @children << child
+      child
+    end
+  end
+end

data/lib/mcts/playout.rb

@@ -0,0 +1,22 @@
+module MCTS
+  class Playout
+
+    attr_reader :game_state
+
+    def initialize(game_state)
+      @game_state = game_state.dup
+    end
+
+    def play
+      my_color = @game_state.last_turn_color
+      playout
+      @game_state.won?(my_color)
+    end
+
+    def playout
+      until @game_state.finished?
+        @game_state.set_move @game_state.generate_move
+      end
+    end
+  end
+end

data/lib/mcts/root.rb

@@ -0,0 +1,49 @@
+module MCTS
+  class Root < Node
+    def initialize(game_state)
+      super game_state, nil, nil
+    end
+
+    def root?
+      true
+    end
+
+    def best_child
+      children.max_by &:win_percentage
+    end
+
+    def best_move
+      best_child.move
+    end
+
+    def explore_tree
+      selected_node = select
+      playout_node =  if selected_node.leaf?
+                        selected_node
+                      else
+                        selected_node.expand
+                      end
+      won = playout_node.rollout
+      playout_node.backpropagate(won)
+    end
+
+    def update_won(won)
+      # logic reversed as the node accumulates its children and has no move
+      # of its own
+      if won
+        self.lost
+      else
+        self.won
+      end
+    end
+
+    private
+    def select
+      node = self
+      until node.untried_moves? || node.leaf? do
+        node = node.uct_select_child
+      end
+      node
+    end
+  end
+end

data/lib/rubykon.rb

@@ -0,0 +1,13 @@
+require_relative 'mcts'
+
+require_relative 'rubykon/group'
+require_relative 'rubykon/group_tracker'
+require_relative 'rubykon/game'
+require_relative 'rubykon/board'
+require_relative 'rubykon/move_validator'
+require_relative 'rubykon/eye_detector'
+require_relative 'rubykon/game_scorer'
+require_relative 'rubykon/exceptions/exceptions'
+require_relative 'rubykon/game_state'
+require_relative 'rubykon/gtp_coordinate_converter'
+require_relative 'rubykon/cli'

data/lib/rubykon/board.rb

@@ -0,0 +1,188 @@
+# Board it acts a bit like a giant 2 dimensional array - but one based
+# not zero based
+module Rubykon
+  class Board
+    include Enumerable
+
+    BLACK = :black
+    WHITE = :white
+    EMPTY = nil
+
+    attr_reader :size, :board
+
+    # weird constructor for dup
+    def initialize(size, board = create_board(size))
+      @size  = size
+      @board = board
+    end
+
+    def each
+      @board.each_with_index do |color, identifier|
+        yield identifier, color
+      end
+    end
+
+    def cutting_point_count
+      @board.size
+    end
+
+    def [](identifier)
+      @board[identifier]
+    end
+
+    def []=(identifier, color)
+      @board[identifier] = color
+    end
+
+    # this method is rather raw and explicit, it gets called a lot
+    def neighbours_of(identifier)
+      x                        = identifier % size
+      y                        = identifier / size
+      right                    = identifier + 1
+      below                    = identifier + @size
+      left                     = identifier - 1
+      above                    = identifier - @size
+      board_edge               = @size - 1
+      not_on_x_edge            = x > 0 && x < board_edge
+      not_on_y_edge            = y > 0 && y < board_edge
+
+      if not_on_x_edge && not_on_y_edge
+        [[right, @board[right]], [below, @board[below]],
+         [left, @board[left]], [above, @board[above]]]
+      else
+        handle_edge_cases(x, y, above, below, left, right, board_edge,
+                          not_on_x_edge, not_on_y_edge)
+      end
+    end
+
+    def neighbour_colors_of(identifier)
+      neighbours_of(identifier).map {|identifier, color| color}
+    end
+
+    def diagonal_colors_of(identifier)
+      diagonal_coordinates(identifier).inject([]) do |res, n_identifier|
+        res << self[n_identifier] if on_board?(n_identifier)
+        res
+      end
+    end
+
+    def on_edge?(identifier)
+      x, y = x_y_from identifier
+      x == 1 || x == size || y == 1 || y == size
+    end
+
+    def on_board?(identifier)
+      identifier >= 0 && identifier < @board.size
+    end
+    
+    COLOR_TO_CHARACTER = {BLACK => ' X', WHITE => ' O', EMPTY => ' .'}
+    CHARACTER_TO_COLOR = COLOR_TO_CHARACTER.invert
+    LEGACY_CONVERSION  = {'X' => ' X', 'O' => ' O', '-' => ' .'}
+    CHARS_PER_GLYPH    = 2
+
+    def ==(other_board)
+      board == other_board.board
+    end
+
+    def to_s
+      @board.each_slice(@size).map do |row|
+        row_chars = row.map do |color|
+          COLOR_TO_CHARACTER.fetch(color)
+        end
+        row_chars.join
+      end.join("\n") << "\n"
+    end
+
+    def dup
+      self.class.new @size, @board.dup
+    end
+
+    MAKE_IT_OUT_OF_BOUNDS = 1000
+
+    def identifier_for(x, y)
+      return nil if x.nil? || y.nil?
+      x = MAKE_IT_OUT_OF_BOUNDS if x > @size || x < 1
+      (y - 1) * @size + (x - 1)
+    end
+
+    def x_y_from(identifier)
+      x = (identifier % (@size)) + 1
+      y = (identifier / (@size)) + 1
+      [x, y]
+    end
+
+    def self.from(string)
+      new_board = new(string.index("\n") / CHARS_PER_GLYPH)
+      each_move_from(string) do |index, color|
+        new_board[index] = color
+      end
+      new_board
+    end
+
+    def self.each_move_from(string)
+      glyphs = string.tr("\n", '').chars.each_slice(CHARS_PER_GLYPH).map(&:join)
+      relevant_glyphs = glyphs.select do |glyph|
+        CHARACTER_TO_COLOR.has_key?(glyph)
+      end
+      relevant_glyphs.each_with_index do |glyph, index|
+        yield index, CHARACTER_TO_COLOR.fetch(glyph)
+      end
+    end
+
+    def self.convert(old_board_string)
+      old_board_string.gsub /[XO-]/, LEGACY_CONVERSION
+    end
+
+    private
+
+    def create_board(size)
+      Array.new(size * size, EMPTY)
+    end
+
+    def handle_edge_cases(x, y, above, below, left, right, board_edge, not_on_x_edge, not_on_y_edge)
+      left_edge   = x == 0
+      right_edge  = x == board_edge
+      top_edge    = y == 0
+      bottom_edge = y == board_edge
+      if left_edge && not_on_y_edge
+        [[right, @board[right]], [below, @board[below]],
+         [above, @board[above]]]
+      elsif right_edge && not_on_y_edge
+        [[below, @board[below]],
+         [left, @board[left]], [above, @board[above]]]
+      elsif top_edge && not_on_x_edge
+        [[right, @board[right]], [below, @board[below]],
+         [left, @board[left]]]
+      elsif bottom_edge && not_on_x_edge
+        [[right, @board[right]],
+         [left, @board[left]], [above, @board[above]]]
+      else
+        handle_corner_case(above, below, left, right, bottom_edge, left_edge, right_edge, top_edge)
+      end
+    end
+
+    def handle_corner_case(above, below, left, right, bottom_edge, left_edge, right_edge, top_edge)
+      if left_edge && top_edge
+        [[right, @board[right]], [below, @board[below]]]
+      elsif left_edge && bottom_edge
+        [[above, @board[above]], [right, @board[right]]]
+      elsif right_edge && top_edge
+        [[left, @board[left]], [below, @board[below]]]
+      elsif right_edge && bottom_edge
+        [[left, @board[left]], [above, @board[above]]]
+      end
+    end
+
+    def diagonal_coordinates(identifier)
+      x = identifier % size
+      if x == 0
+        [identifier + 1 - @size, identifier + 1 + @size]
+      elsif x == size - 1
+        [identifier - 1 - @size, identifier - 1 + @size]
+      else
+        [identifier - 1 - @size, identifier - 1 + @size,
+         identifier + 1 - @size, identifier + 1 + @size]
+      end
+    end
+  end
+end