rubykon 0.3.0

data/lib/rubykon/group_tracker.rb

@@ -0,0 +1,144 @@
+module Rubykon
+  class GroupTracker
+
+    attr_reader :groups, :stone_to_group
+
+    def initialize(groups = {}, stone_to_group = {})
+      @groups         = groups
+      @stone_to_group = stone_to_group
+    end
+
+    def assign(identifier, color, board)
+      neighbours_by_color = color_to_neighbour(board, identifier)
+      join_group_of_friendly_stones(neighbours_by_color[color], identifier)
+      create_own_group(identifier) unless group_id_of(identifier)
+      add_liberties(neighbours_by_color[Board::EMPTY], identifier)
+      take_liberties_of_enemies(neighbours_by_color[Game.other_color(color)], identifier, board, color)
+    end
+
+    def liberty_count_at(identifier)
+      group_of(identifier).liberty_count
+    end
+
+    def group_id_of(identifier)
+      @stone_to_group[identifier]
+    end
+
+    def group_of(identifier)
+      group(group_id_of(identifier))
+    end
+
+    def group(id)
+      @groups[id]
+    end
+
+    def stone_joins_group(stone_identifier, group_identifier)
+      @stone_to_group[stone_identifier] = group_identifier
+    end
+
+    def dup
+      self.class.new(dup_groups, @stone_to_group.dup)
+    end
+
+    private
+    def color_to_neighbour(board, identifier)
+      neighbors = board.neighbours_of(identifier)
+      hash = neighbors.inject({}) do |hash, (n_identifier, color)|
+        (hash[color] ||= []) << n_identifier
+        hash
+      end
+      hash.default = []
+      hash
+    end
+
+    def take_liberties_of_enemies(enemy_neighbours, identifier, board, capturer_color)
+      my_group = group_of(identifier)
+      captures = enemy_neighbours.inject([]) do |caught, enemy_identifier|
+        enemy_group = group_of(enemy_identifier)
+        remove_liberties(enemy_identifier, enemy_group, identifier, my_group)
+        collect_captured_groups(caught, enemy_group)
+      end
+      remove_caught_groups(board, capturer_color, captures)
+    end
+
+    def remove_liberties(enemy_identifier, enemy_group, identifier, my_group)
+      enemy_group.remove_liberty(identifier)
+      # this needs to be the identifier and not the group, as groups
+      # might get merged
+      my_group.add_enemy_group_at(enemy_identifier)
+    end
+
+    def collect_captured_groups(caught, enemy_group)
+      if enemy_group.caught? && !caught.include?(enemy_group)
+        caught << enemy_group
+      end
+      caught
+    end
+
+    def remove_caught_groups(board, capturer_color, caught)
+      captures = caught.inject([]) do |captures, enemy_group|
+        captures + remove(enemy_group, board)
+      end
+      captures
+    end
+
+    def remove(enemy_group, board)
+      regain_liberties_from_capture(enemy_group)
+      delete_group(enemy_group)
+      remove_captured_stones(board, enemy_group)
+    end
+
+    def remove_captured_stones(board, enemy_group)
+      captured_stones = enemy_group.stones
+      captured_stones.each do |identifier|
+        @stone_to_group.delete identifier
+        board[identifier] = Board::EMPTY
+      end
+      captured_stones
+    end
+
+    def delete_group(enemy_group)
+      @groups.delete(enemy_group.identifier)
+    end
+
+    def regain_liberties_from_capture(enemy_group)
+      neighboring_groups_of(enemy_group).each do |neighbor_group|
+        neighbor_group.gain_liberties_from_capture_of(enemy_group, self)
+      end
+    end
+
+    def neighboring_groups_of(enemy_group)
+      enemy_group.liberties.map do |identifier, _|
+        group_of(identifier)
+      end.compact.uniq
+    end
+
+    def add_liberties(liberties, identifier)
+      liberties.each do |liberty_identifier|
+        group_of(identifier).add_liberty(liberty_identifier)
+      end
+    end
+
+    def join_group_of_friendly_stones(friendly_stones, identifier)
+      friendly_stones.each do |f_identifier, _color|
+        friendly_group = group_of(f_identifier)
+        friendly_group.connect identifier, group_of(identifier), self
+      end
+    end
+
+    def create_own_group(identifier)
+      # we can use the identifier of the stone, as it should not be taken
+      # (it may have been taken before, but for that stone to be played the
+      # other group would have had to be captured before)
+      @groups[identifier] = Group.new(identifier)
+      @stone_to_group[identifier] = identifier
+    end
+
+    def dup_groups
+      @groups.inject({}) do |dupped, (key, group)|
+        dupped[key] = group.dup
+        dupped
+      end
+    end
+  end
+end

data/lib/rubykon/gtp_coordinate_converter.rb

@@ -0,0 +1,25 @@
+module Rubykon
+  class GTPCoordinateConverter
+
+    X_CHARS = ('A'..'Z').reject { |c| c == 'I'.freeze }
+
+    def initialize(board)
+      @board = board
+    end
+
+    def from(string)
+      x = string[0]
+      y = string[1..-1]
+      x_index = X_CHARS.index(x) + 1
+      y_index = @board.size - y.to_i + 1
+      @board.identifier_for(x_index, y_index)
+    end
+
+    def to(index)
+      x, y = @board.x_y_from(index)
+      x_char = X_CHARS[x - 1]
+      y_index = @board.size - y + 1
+      "#{x_char}#{y_index}"
+    end
+  end
+end

data/lib/rubykon/move_validator.rb

@@ -0,0 +1,55 @@
+module Rubykon
+  class MoveValidator
+    
+    def valid?(identifier, color, game)
+      board = game.board
+      no_double_move?(color, game) &&
+        (Game.pass?(identifier) ||
+        (move_on_board?(identifier, board) &&
+          spot_unoccupied?(identifier, board) &&
+          no_suicide_move?(identifier, color, game) &&
+          no_ko_move?(identifier, game)))
+    end
+
+    def trusted_valid?(identifier, color, game)
+      board = game.board
+      spot_unoccupied?(identifier, board) &&
+        no_ko_move?(identifier, game) &&
+        no_suicide_move?(identifier, color, game)
+
+    end
+
+    private
+    def no_double_move?(color, game)
+      color == game.next_turn_color
+    end
+
+    def move_on_board?(identifier, board)
+      board.on_board?(identifier)
+    end
+    
+    def spot_unoccupied?(identifier, board)
+      board[identifier] == Board::EMPTY
+    end
+
+    def no_suicide_move?(identifier, color, game)
+      enemy_color         = Game.other_color(color)
+      board               = game.board
+      board_neighbours_of = board.neighbours_of(identifier)
+      p identifier if board_neighbours_of.nil?
+      board_neighbours_of.any? do |n_identifier, n_color|
+        (n_color == Board::EMPTY) ||
+          (n_color == color) && (liberties_at(n_identifier, game) > 1) ||
+          (n_color == enemy_color) && (liberties_at(n_identifier, game) <= 1)
+      end
+    end
+
+    def liberties_at(identifier, game)
+      game.group_tracker.liberty_count_at(identifier)
+    end
+
+    def no_ko_move?(identifier, game)
+      identifier != game.ko
+    end
+  end
+end

data/lib/rubykon/version.rb

@@ -0,0 +1,3 @@
+module Rubykon
+  VERSION = "0.3.0"
+end

data/rubykon.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rubykon/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubykon"
+  spec.version       = Rubykon::VERSION
+  spec.authors       = ["Tobias Pfeiffer"]
+  spec.email         = ["pragtob@gmail.com"]
+
+  spec.summary       = %q{An AI to play Go using Monte Carlo Tree Search.}
+  spec.description   = %q{An AI to play Go using Monte Carlo Tree Search. Currently includes the mcts gem and benchmark/avg. Works on all major ruby versions.}
+  spec.homepage      = "https://github.com/PragTob/rubykon"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: rubykon
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Tobias Pfeiffer
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-16 00:00:00.000000000 Z
+dependencies: []
+description: An AI to play Go using Monte Carlo Tree Search. Currently includes the
+  mcts gem and benchmark/avg. Works on all major ruby versions.
+email:
+- pragtob@gmail.com
+executables:
+- rubykon
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Guardfile
+- LICENSE
+- POSSIBLE_IMPROVEMENTS.md
+- README.md
+- Rakefile
+- benchmark/benchmark.sh
+- benchmark/full_playout.rb
+- benchmark/mcts_avg.rb
+- benchmark/playout.rb
+- benchmark/playout_micros.rb
+- benchmark/profiling/full_playout.rb
+- benchmark/profiling/mcts.rb
+- benchmark/results/HISTORY.md
+- benchmark/scoring.rb
+- benchmark/scoring_micros.rb
+- benchmark/support/benchmark-ips.rb
+- benchmark/support/benchmark-ips_shim.rb
+- benchmark/support/playout_help.rb
+- examples/mcts_laziness.rb
+- exe/rubykon
+- lib/benchmark/avg.rb
+- lib/benchmark/avg/benchmark_suite.rb
+- lib/benchmark/avg/job.rb
+- lib/mcts.rb
+- lib/mcts/examples/double_step.rb
+- lib/mcts/mcts.rb
+- lib/mcts/node.rb
+- lib/mcts/playout.rb
+- lib/mcts/root.rb
+- lib/rubykon.rb
+- lib/rubykon/board.rb
+- lib/rubykon/cli.rb
+- lib/rubykon/exceptions/exceptions.rb
+- lib/rubykon/exceptions/illegal_move_exception.rb
+- lib/rubykon/eye_detector.rb
+- lib/rubykon/game.rb
+- lib/rubykon/game_scorer.rb
+- lib/rubykon/game_state.rb
+- lib/rubykon/group.rb
+- lib/rubykon/group_tracker.rb
+- lib/rubykon/gtp_coordinate_converter.rb
+- lib/rubykon/move_validator.rb
+- lib/rubykon/version.rb
+- rubykon.gemspec
+homepage: https://github.com/PragTob/rubykon
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: An AI to play Go using Monte Carlo Tree Search.
+test_files: []