rubykon 0.3.0

data/lib/rubykon/cli.rb

@@ -0,0 +1,122 @@
+module Rubykon
+  class CLI
+
+    EXIT            = /exit/i
+    CHAR_LABELS     = GTPCoordinateConverter::X_CHARS
+    X_LABEL_PADDING = ' '.freeze * 4
+    Y_LABEL_WIDTH   = 3
+
+    def initialize(output = $stdout, input = $stdin)
+      @output     = output
+      @input      = input
+      @state      = :init
+    end
+
+    def start
+      @output.puts 'Please enter a board size (common sizes are 9, 13, and 19)'
+      size = get_digit_input
+      @output.puts <<-PLAYOUTS
+Please enter the number of playouts you'd like rubykon to make!
+More playouts means rubykon is stronger, but also takes longer.
+For 9x9 10000 is an acceptable value, for 19x19 1000 already take a long time.
+      PLAYOUTS
+      playouts = get_digit_input
+      init_game(size, playouts)
+      game_loop
+    end
+
+    private
+    def get_digit_input
+      input = get_input
+      until input.match /^\d\d*$/
+        @output.puts "Input has to be a number. Please try again!"
+        input = get_input
+      end
+      input
+    end
+
+    def get_input
+      @output.print '> '
+      input = @input.gets.chomp
+      exit_if_desired(input)
+      input
+    end
+
+    def exit_if_desired(input)
+      quit if input.match EXIT
+    end
+
+    def quit
+      @output.puts "too bad, bye bye!"
+      exit
+    end
+
+    def init_game(size, playouts)
+      board_size = size.to_i
+      @output.puts "Great starting a #{board_size}x#{board_size} game with #{playouts} playouts"
+      @game          = Game.new board_size
+      @game_state    = GameState.new @game
+      @mcts          = MCTS::MCTS.new
+      @board         = @game.board
+      @gtp_converter = GTPCoordinateConverter.new(@board)
+      @playouts      = playouts.to_i
+    end
+
+    def game_loop
+      print_board
+      while true
+        if bot_turn?
+          bot_move
+        else
+          human_move
+        end
+      end
+    end
+
+    def bot_turn?
+      @game.next_turn_color == Board::BLACK
+    end
+
+    def print_board
+      @output.puts labeled_board
+    end
+
+    def labeled_board
+      rows = []
+      x_labels = X_LABEL_PADDING + CHAR_LABELS.take(@board.size).join(' ')
+      rows << x_labels
+      board_rows = @board.to_s.split("\n").each_with_index.map do |row, i|
+        y_label = "#{@board.size - i}".rjust(Y_LABEL_WIDTH)
+        y_label + row + y_label
+      end
+      rows += board_rows
+      rows << x_labels
+      rows.join "\n"
+    end
+
+    def bot_move
+      @output.puts 'Rubykon is thinking...'
+      root = @mcts.start @game_state, @playouts
+      move = root.best_move
+      best_children = root.children.sort_by(&:win_percentage).reverse.take(10)
+      @output.puts best_children.map {|child| "#{@gtp_converter.to(child.move.first)} => #{child.win_percentage}"}.join "\n"
+      make_move(move)
+    end
+
+    def human_move
+      @output.puts "Make a move in the form XY, e.g. A19, D7 as the labels indicate!"
+      coords = get_input
+      identifier = @gtp_converter.from(coords)
+      move = [identifier, :white]
+      make_move(move)
+    end
+
+    def make_move(move)
+      @game_state.set_move move
+      print_board
+      @output.puts "#{move.last} played at #{@gtp_converter.to(move.first)}"
+      @output.puts "#{@game.next_turn_color}'s turn to move!'"
+    end
+
+  end
+end

data/lib/rubykon/exceptions/exceptions.rb

@@ -0,0 +1 @@
+require_relative 'illegal_move_exception'

data/lib/rubykon/exceptions/illegal_move_exception.rb

@@ -0,0 +1,4 @@
+module Rubykon
+  class IllegalMoveException < ::RuntimeError
+  end
+end

data/lib/rubykon/eye_detector.rb

@@ -0,0 +1,27 @@
+module Rubykon
+  class EyeDetector
+    def is_eye?(identifier, board)
+      candidate_eye_color = candidate_eye_color(identifier, board)
+      return false unless candidate_eye_color
+      is_real_eye?(identifier, board, candidate_eye_color)
+    end
+
+    def candidate_eye_color(identifier, board)
+      neighbor_colors = board.neighbour_colors_of(identifier)
+      candidate_eye_color = neighbor_colors.first
+      return false if candidate_eye_color == Board::EMPTY
+      if neighbor_colors.all? {|color| color == candidate_eye_color}
+        candidate_eye_color
+      else
+        nil
+      end
+    end
+
+    private
+    def is_real_eye?(identifier, board, candidate_eye_color)
+      enemy_color = Game.other_color(candidate_eye_color)
+      enemy_count = board.diagonal_colors_of(identifier).count(enemy_color)
+      (enemy_count < 1) || (!board.on_edge?(identifier) && enemy_count < 2)
+    end
+  end
+end

data/lib/rubykon/game.rb

@@ -0,0 +1,115 @@
+module Rubykon
+  class Game
+    attr_reader :board, :group_tracker, :move_count, :ko, :captures
+    attr_accessor :komi
+
+    DEFAULT_KOMI = 6.5
+
+    # the freakish constructor is here so that we can have a decent dup
+    def initialize(size = 19, komi = DEFAULT_KOMI, board = Board.new(size),
+                   move_count = 0, consecutive_passes = 0,
+                   ko = nil, captures = initial_captures,
+                   move_validator = MoveValidator.new,
+                   group_tracker = GroupTracker.new)
+      @board              = board
+      @komi               = komi
+      @move_count         = move_count
+      @consecutive_passes = consecutive_passes
+      @ko                 = ko
+      @captures           = captures
+      @move_validator     = move_validator
+      @group_tracker      = group_tracker
+    end
+
+    def play(x, y, color)
+      identifier = @board.identifier_for(x, y)
+      if valid_move?(identifier, color)
+        set_valid_move(identifier, color)
+        true
+      else
+        false
+      end
+    end
+
+    def play!(x, y, color)
+      raise IllegalMoveException unless play(x, y, color)
+    end
+
+    def no_moves_played?
+      @move_count == 0
+    end
+
+    def next_turn_color
+      move_count.even? ? Board::BLACK : Board::WHITE
+    end
+
+    def finished?
+      @consecutive_passes >= 2
+    end
+
+    def set_valid_move(identifier, color)
+      @move_count += 1
+      if Game.pass?(identifier)
+        @consecutive_passes += 1
+      else
+        set_move(color, identifier)
+      end
+    end
+
+    def safe_set_move(identifier, color)
+      return if color == Board::EMPTY
+      set_valid_move(identifier, color)
+    end
+
+    def dup
+      self.class.new @size, @komi, @board.dup, @move_count, @consecutive_passes,
+                     @ko, @captures.dup, @move_validator, @group_tracker.dup
+    end
+
+    def self.other_color(color)
+      if color == :black
+        :white
+      else
+        :black
+      end
+    end
+
+    def self.pass?(identifier)
+      identifier.nil?
+    end
+
+    def self.from(string)
+      game = new(string.index("\n") / Board::CHARS_PER_GLYPH)
+      Board.each_move_from(string) do |identifier, color|
+        game.safe_set_move(identifier, color)
+      end
+      game
+    end
+
+    private
+    def initial_captures
+      {Board::BLACK => 0, Board::WHITE => 0}
+    end
+
+    def valid_move?(identifier, color)
+      @move_validator.valid?(identifier, color, self)
+    end
+
+    def set_move(color, identifier)
+      @board[identifier] = color
+      potential_eye = EyeDetector.new.candidate_eye_color(identifier, @board)
+      captures = @group_tracker.assign(identifier, color, board)
+      determine_ko_move(captures, potential_eye)
+      @captures[color] += captures.size
+      @consecutive_passes = 0
+    end
+
+    def determine_ko_move(captures, potential_eye)
+      if captures.size == 1 && potential_eye
+        @ko = captures[0]
+      else
+        @ko = nil
+      end
+    end
+  end
+end

data/lib/rubykon/game_scorer.rb

@@ -0,0 +1,62 @@
+module Rubykon
+  class GameScorer
+    def score(game)
+      game_score = {Board::BLACK => 0, Board::WHITE => game.komi}
+      score_board(game, game_score)
+      add_captures(game, game_score)
+      determine_winner(game_score)
+      game_score
+    end
+
+    private
+    def score_board(game, game_score)
+      board = game.board
+      board.each do |identifier, color|
+        if color == Board::EMPTY
+          score_empty_cutting_point(identifier, board, game_score)
+        else
+          game_score[color] += 1
+        end
+      end
+    end
+
+    def score_empty_cutting_point(identifier, board, game_score)
+      neighbor_colors = board.neighbour_colors_of(identifier)
+      candidate_color = find_candidate_color(neighbor_colors)
+      return unless candidate_color
+      if only_one_color_adjacent?(neighbor_colors, candidate_color)
+        game_score[candidate_color] += 1
+      end
+    end
+
+    def find_candidate_color(neighbor_colors)
+      neighbor_colors.find do |color|
+        color != Board::EMPTY
+      end
+    end
+
+    def only_one_color_adjacent?(neighbor_colors, candidate_color)
+      enemy_color = Game.other_color(candidate_color)
+      neighbor_colors.all? do |color|
+        color != enemy_color
+      end
+    end
+
+    def add_captures(game, game_score)
+      game_score[Board::BLACK] += game.captures[Board::BLACK]
+      game_score[Board::WHITE] += game.captures[Board::WHITE]
+    end
+
+    def determine_winner(game_score)
+      game_score[:winner] = if black_won?(game_score)
+                              Board::BLACK
+                            else
+                              Board::WHITE
+                            end
+    end
+
+    def black_won?(game_score)
+      game_score[Board::BLACK] > game_score[Board::WHITE]
+    end
+  end
+end

data/lib/rubykon/game_state.rb

@@ -0,0 +1,93 @@
+module Rubykon
+  class GameState
+
+    attr_reader :game
+
+    def initialize(game = Game.new,
+                   validator = MoveValidator.new,
+                   eye_detector = EyeDetector.new)
+      @game = game
+      @validator = validator
+      @eye_detector = eye_detector
+    end
+
+    def finished?
+      @game.finished?
+    end
+
+    def generate_move
+      generate_random_move
+    end
+
+    def set_move(move)
+      identifier = move.first
+      color = move.last
+      @game.set_valid_move identifier, color
+    end
+
+    def dup
+      self.class.new @game.dup, @validator, @eye_detector
+    end
+
+    def won?(color)
+      score[:winner] == color
+    end
+
+    def all_valid_moves
+      color = @game.next_turn_color
+      @game.board.inject([]) do |valid_moves, (identifier, _field_color)|
+        valid_moves << [identifier, color] if plausible_move?(identifier, color)
+        valid_moves
+      end
+    end
+
+    def score
+      @score ||= GameScorer.new.score(@game)
+    end
+
+    def last_turn_color
+      Game.other_color(next_turn_color)
+    end
+
+    private
+    def generate_random_move
+      color = @game.next_turn_color
+      cp_count   = @game.board.cutting_point_count
+      start_point = rand(cp_count)
+      identifier = start_point
+      passes = 0
+
+      until searched_whole_board?(identifier, passes, start_point) ||
+        plausible_move?(identifier, color) do
+        if identifier >= cp_count - 1
+          identifier = 0
+          passes += 1
+        else
+          identifier += 1
+        end
+      end
+
+      if searched_whole_board?(identifier, passes, start_point)
+        pass_move(color)
+      else
+        [identifier, color]
+      end
+    end
+
+    def searched_whole_board?(identifier, passes, start_point)
+      passes > 0 && identifier >= start_point
+    end
+
+    def pass_move(color)
+      [nil, color]
+    end
+
+    def next_turn_color
+      @game.next_turn_color
+    end
+
+    def plausible_move?(identifier, color)
+      @validator.trusted_valid?(identifier, color, @game) && !@eye_detector.is_eye?(identifier, @game.board)
+    end
+  end
+end

data/lib/rubykon/group.rb

@@ -0,0 +1,99 @@
+module Rubykon
+  class Group
+
+    attr_reader :identifier, :stones, :liberties, :liberty_count
+
+    NOT_SET = :not_set
+
+    def initialize(id, stones = [id], liberties = {}, liberty_count = 0)
+      @identifier    = id
+      @stones        = stones
+      @liberties     = liberties
+      @liberty_count = liberty_count
+    end
+    
+    def connect(stone_identifier, stone_group, group_tracker)
+      return if stone_group == self
+      if stone_group
+        merge(stone_group, group_tracker)
+      else
+        add_stone(stone_identifier, group_tracker)
+      end
+      remove_connector_liberty(stone_identifier)
+    end
+
+    def gain_liberties_from_capture_of(captured_group, group_tracker)
+      new_liberties = @liberties.select do |_identifier, stone_identifier|
+        group_tracker.group_id_of(stone_identifier) == captured_group.identifier
+      end
+      new_liberties.each do |identifier, _group_id|
+        add_liberty(identifier)
+      end
+    end
+
+    def dup
+      self.class.new @identifier, @stones.dup, @liberties.dup, @liberty_count
+    end
+
+    def add_liberty(identifier)
+      return if already_counted_as_liberty?(identifier, Board::EMPTY)
+      @liberties[identifier] = Board::EMPTY
+      @liberty_count += 1
+    end
+
+    def remove_liberty(identifier)
+      return if already_counted_as_liberty?(identifier, identifier)
+      @liberties[identifier] = identifier
+      @liberty_count -= 1
+    end
+
+    def caught?
+      @liberty_count <= 0
+    end
+
+    def add_enemy_group_at(enemy_identifier)
+      liberties[enemy_identifier] = enemy_identifier
+    end
+    
+    private
+
+    def merge(other_group, group_tracker)
+      merge_stones(other_group, group_tracker)
+      merge_liberties(other_group)
+    end
+
+    def merge_stones(other_group, group_tracker)
+      other_group.stones.each do |identifier|
+        add_stone(identifier, group_tracker)
+      end
+    end
+
+    def merge_liberties(other_group)
+      @liberty_count += other_group.liberty_count
+      @liberties.merge!(other_group.liberties) do |_key, my_identifier, other_identifier|
+        if shared_liberty?(my_identifier, other_identifier)
+          @liberty_count -= 1
+        end
+        my_identifier
+      end
+    end
+
+    def add_stone(identifier, group_tracker)
+      group_tracker.stone_joins_group(identifier, @identifier)
+      @stones << identifier
+    end
+
+    def shared_liberty?(my_identifier, other_identifier)
+      my_identifier == Board::EMPTY || other_identifier == Board::EMPTY
+    end
+
+    def remove_connector_liberty(identifier)
+      @liberties.delete(identifier)
+      @liberty_count -= 1
+    end
+
+    def already_counted_as_liberty?(identifier, value)
+      @liberties.fetch(identifier, NOT_SET) == value
+    end
+  end
+end