rubykon 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0c6f51cb33c58227a82783ff663d546397ef750
+  data.tar.gz: 2764e68e3b5a9ecc0ed8b1e62273201bf8748962
+SHA512:
+  metadata.gz: 8d3d477881d123c94556c396885002ff3e01708f6f147c8aa1ceb7b625189de8d6f59202393d8f9806e75ef7743ccbd204c6f37e136b5dbe26b7f631eb5067f3
+  data.tar.gz: e5b6acffc005f3e3ad2098cb7c3efc37b95253e8d58288a486d46f43b7c12dd047e80b528dd95ad47fd7d5ad4b510bcea5db48b6da333d1767dd9b810c2b4993

data/.gitignore

@@ -0,0 +1,5 @@
+Gemfile.lock
+profiling.html
+.bundle
+.jruby+truffle_bundle
+pkg/

data/.ruby-gemset

@@ -0,0 +1 @@
+rubykon

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.3

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - jruby-19mode
+  - rbx-19mode
+  - 2.2
+  - jruby-9.0.3.0
+script: bundle exec rspec spec
+
+addons:
+  code_climate:
+    repo_token: fab8afb587984cc2f6100be9c660e966ac3fb5e113458fb381267bfffcef15fe

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+## 0.3 (2015-11-12)
+Implement full bot together with Monte Carlo Tree Search, as well as a more coarse grained benchmarking tool to benchmark full MCTS runs. Also add a CLI. Mostly a feature release.
+
+### Performance
+* Faster and more reliable move selection
+* optimize neighbours_of by enumerating possibilities, raw but effective
+
+### Features
+* Full Monte Carlo Tree Search implementation
+* Basic CLI implementation
+* benchmark/avg to do more coarse grained benchmarking
+* More readable string board representation
+* Added License (oops)
+* Added CoC
+
+### Bugfixes
+* correctly count captures for score
+
+## 0.2 (2015-10-03)
+Rewrote data representation to be smaller and do way less allocations.
+
+### Performance
+* board is now a one dimensional array with each element corresponding to one cutting point (e.g. 1-1 is 0, 3-1 is 2, 1-2 is 19 (on 19x19).
+* no more stone class, the board just stores the color of the stone there. Instead of `Stone` objects, an identifier (see above) and its color are passed around.
+* what would be a ko move is now stored on the game, making checking faster and easier
+* dupping games is easier thanks to simpler data structures
+
+### Bugfixes
+* captures are correctly included when scoring a game
+
+## 0.1 (2015-09-25)
+Basic game version, able to perform random playouts and benchmark those.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# all dev dependencies
+gem 'rspec', '~> 3.3'
+gem 'guard-rspec'
+gem "codeclimate-test-reporter", group: :test, require: nil
+gem "benchmark-ips"

data/Guardfile

@@ -0,0 +1,12 @@
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (C) 2012-2015 Tobias Pfeiffer
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/POSSIBLE_IMPROVEMENTS.md

@@ -0,0 +1,25 @@
+# Possible Improvements
+
+Possible improvements to try out in the implementation :)
+
+## Playout speed
+
+### Board representation
+* Reuse stones instead of creating new ones (would probably require a separate move class)
+* just use symbols on the board instead of full fledged objects
+* use a one dimensional array as the board (can map back to original using modulo etc.)
+* use multiple bitmasks (or a bigger one) to represent board state (we have 3 states so a simple mask won't do)
+* neighbour_colors methods
+
+### Group
+* remove references to stones/liberties from obsolete groups (when it is merged in another group or taken off the board)
+* in liberties, don't point to stones but point to groups (be careful as no group is nil... and that then is not good with hash lookups)
+
+### Move gen
+* check self atari?
+
+### Scoring
+* use more efficient scoring algorithm (michi floodfill like?)
+
+### Move generation
+* sensibly choose moves and not just that random barrage... possiby using an Enumerator

data/README.md

@@ -0,0 +1,36 @@
+# Rubykon [![Build Status](https://secure.travis-ci.org/PragTob/rubykon.png?branch=master)](https://travis-ci.org/PragTob/rubykon)[![Code Climate](https://codeclimate.com/github/PragTob/Rubykon.png)](https://codeclimate.com/github/PragTob/Rubykon)[![Test Coverage](https://codeclimate.com/github/PragTob/Rubykon/badges/coverage.svg)](https://codeclimate.com/github/PragTob/Rubykon/coverage)
+A Go-Engine being built in Ruby. 
+
+### Status?
+A naive very slow implementation of random playouts. Next up making it faster... or implementing the mcts bits. We'll see. Don't use and judge yet, some pretty inefficient stuff in here :D
+
+### Why would you build a Go-Bot in Ruby?
+Cause it's fun.
+
+### Running truffle
+
+Go ahead and [install from source](https://github.com/jruby/jruby/wiki/Truffle#from-source). Then you have to specify the graal VM when you execute something like this:
+
+    JAVACMD=~/dev/graalvm-jdk1.8.0/bin/java ../jruby/bin/jruby -X+T -e 'puts Truffle.graal?'
+    
+If this (adjusted to your paths) prints `true` then the setup is good so far.
+ 
+Next up, install the jruby+truffle tool. Go into the jruby directory you checked out and make sure you use the same ruby version/gemset you want to use (this installs a gem). Then do:
+ 
+    tool/jt.rb install-tool
+    
+With this installed you can then setup graal in your repository (i.e. rubykon), this install gems etc.:
+
+    jruby+truffle setup
+    
+This should now still print true:
+
+    jruby+truffle --graal-path ../graalvm-jdk1.8.0/bin/java run --graal -- -e 'p Truffle.graal?'
+    
+You can then use it like this to run benchmarks et. al.:
+
+    jruby+truffle --graal-path ../graalvm-jdk1.8.0/bin/java run --graal -J-Xmx1500m benchmark/mcts.rb
+    
+The `-J-Xmx1500m` is important as truffle needs more heap space.
+    
+You can also run the specs via `jruby+truffle run -S rspec spec/`

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/benchmark/benchmark.sh

@@ -0,0 +1,22 @@
+#! /bin/bash --login
+
+script_name=$1
+
+declare -A RUBY_TO_ARG=( ["2.2"]="" [jruby]="" [jruby-9]="--server -Xcompile.invokedynamic=true -J-Xmx1500m" ["rbx-2.5.8"]="" [jruby-1]="" [1.9.3]="" )
+
+for ruby in "${!RUBY_TO_ARG[@]}"
+do
+  echo Running $ruby with ${RUBY_TO_ARG[$ruby]}
+  rvm use $ruby
+  ruby -v
+  ruby ${RUBY_TO_ARG[$ruby]} $script_name
+  echo
+  echo
+done
+
+rvm use 2.2@rubykon
+echo Running truffle graal with enough heap space
+jruby+truffle run --graal -- -e "puts RUBY_DESCRIPTION"
+jruby+truffle run --graal -J-Xmx1500m $script_name
+echo
+echo

data/benchmark/full_playout.rb

@@ -0,0 +1,17 @@
+require_relative '../lib/rubykon'
+require_relative 'support/playout_help'
+require_relative 'support/benchmark-ips'
+
+Benchmark.ips do |benchmark|
+  benchmark.config time: 30, warmup: 60
+
+  benchmark.report '9x9 full playout (+ score)' do
+    full_playout_for 9
+  end
+  benchmark.report '13x13 full playout (+ score)' do
+    full_playout_for 13
+  end
+  benchmark.report '19x19 full playout (+ score)' do
+    full_playout_for 19
+  end
+end

data/benchmark/mcts_avg.rb

@@ -0,0 +1,23 @@
+require_relative '../lib/rubykon'
+require_relative '../lib/benchmark/avg'
+
+Benchmark.avg do |benchmark|
+  game_state_9 = Rubykon::GameState.new Rubykon::Game.new(9)
+  game_state_13 = Rubykon::GameState.new Rubykon::Game.new(13)
+  game_state_19 = Rubykon::GameState.new Rubykon::Game.new(19)
+  mcts = MCTS::MCTS.new
+
+  benchmark.config warmup: 180, time: 120
+
+  benchmark.report "9x9 10_000 iterations" do
+    mcts.start game_state_9, 10_000
+  end
+
+  benchmark.report "13x13 2_000 iterations" do
+    mcts.start game_state_13, 2_000
+  end
+
+  benchmark.report "19x19 1_000 iterations" do
+    mcts.start game_state_19, 1_000
+  end
+end

data/benchmark/playout.rb

@@ -0,0 +1,15 @@
+require_relative '../lib/rubykon'
+require_relative 'support/playout_help'
+require_relative 'support/benchmark-ips'
+
+Benchmark.ips do |benchmark|
+  benchmark.report '9x9 playout' do
+    playout_for 9
+  end
+  benchmark.report '13x13 playout' do
+    playout_for 13
+  end
+  benchmark.report '19x19 playout' do
+    playout_for 19
+  end
+end

data/benchmark/playout_micros.rb

@@ -0,0 +1,188 @@
+require_relative '../lib/rubykon'
+require_relative 'support/playout_help'
+require_relative 'support/benchmark-ips'
+
+class Rubykon::GameState
+  public :plausible_move?
+  public :next_turn_color
+end
+
+class Rubykon::EyeDetector
+  public :candidate_eye_color
+  public :is_real_eye?
+end
+
+class Rubykon::MoveValidator
+  public :no_suicide_move?
+end
+
+class Rubykon::GroupTracker
+  public :color_to_neighbour
+  public :create_own_group
+  public :take_liberties_of_enemies
+  public :join_group_of_friendly_stones
+  public :add_liberties
+end
+
+
+Benchmark.ips do |benchmark|
+  empty_game = Rubykon::GameState.new Rubykon::Game.new 19
+  mid_game = empty_game.dup
+  200.times do
+    mid_game.set_move mid_game.generate_move
+  end
+  finished_game = playout_for(19).game_state
+
+  games = {
+    empty_game    => 'empty game',
+    mid_game      => 'mid game (200 moves played)',
+    finished_game => 'finished game'
+  }
+
+  games.each do |game_state, description|
+
+    game = game_state.game
+    board = game.board
+
+    benchmark.report "#{description}: finished?" do
+      game_state.finished?
+    end
+
+    benchmark.report "#{description}: generate_move" do
+      game_state.generate_move
+    end
+
+    color = game_state.next_turn_color
+
+    benchmark.report "#{description}: plausible_move?" do
+      identifier = rand(361)
+      game_state.plausible_move?(identifier, color)
+    end
+
+    validator    = Rubykon::MoveValidator.new
+
+    benchmark.report "#{description}: valid?" do
+      identifier = rand(361)
+      validator.valid?(identifier, color, game)
+    end
+
+    benchmark.report "#{description}: no_suicide_move?" do
+      identifier = rand(361)
+      validator.no_suicide_move?(identifier, color, game)
+    end
+
+    eye_detector = Rubykon::EyeDetector.new
+
+    benchmark.report "#{description}: is_eye?" do
+      identifier = rand(361)
+      eye_detector.is_eye?(identifier, board)
+    end
+
+    benchmark.report "#{description}: candidate_eye_color" do
+      identifier = rand(361)
+      eye_detector.candidate_eye_color(identifier, board)
+    end
+
+    candidate_identifier = rand(361)
+    candidate_eye_color = eye_detector.candidate_eye_color(candidate_identifier, board)
+
+    benchmark.report "#{description}: is_real_eye?" do
+      eye_detector.is_real_eye?(candidate_identifier, board, candidate_eye_color)
+    end
+
+    benchmark.report "#{description}: diagonal_colors_of" do
+      identifier = rand(361)
+      board.diagonal_colors_of(identifier)
+    end
+
+    benchmark.report "#{description}: dup" do
+      game_state.dup
+    end
+
+    benchmark.report "#{description}: set_valid_move" do
+      game.dup.set_valid_move rand(361), color
+    end
+
+    benchmark.report "#{description}: assign" do
+      group_tracker = game.group_tracker.dup
+      group_tracker.assign(rand(361), color, board)
+    end
+
+    group_tracker = game.group_tracker.dup
+
+    benchmark.report "#{description}: color_to_neighbour" do
+      group_tracker.color_to_neighbour(board, rand(361))
+    end
+  end
+
+
+  # more rigorous setup, values gotta be right so we can't just take
+  # our randomly played out boards. Also this doesn't make much sense
+  # on the empty or finished board.
+
+  game = Rubykon::Game.new(19)
+  group_tracker = game.group_tracker
+
+  stone1 = 55
+  liberties_1 = {
+    54 => Rubykon::Board::EMPTY,
+    56 => 56,
+    36 => Rubykon::Board::EMPTY,
+    74 => Rubykon::Board::EMPTY,
+    57 => Rubykon::Board::EMPTY
+  }
+  group_1 = Rubykon::Group.new(stone1, [stone1], liberties_1, 4)
+  group_tracker.stone_to_group[55] = 1
+  group_tracker.groups[1] = group_1
+  group_tracker.create_own_group(56)
+
+  stone2 = 33
+  liberties_2 = {
+    32 => Rubykon::Board::EMPTY,
+    34 => 34,
+    24 => Rubykon::Board::EMPTY,
+    54 => Rubykon::Board::EMPTY,
+    55 => Rubykon::Board::EMPTY
+  }
+  group_2 = Rubykon::Group.new(stone2, [stone2], liberties_2, 4)
+  group_tracker.stone_to_group[33] = 2
+  group_tracker.groups[2] = group_2
+  group_tracker.create_own_group(34)
+
+  # "small groups" as they have few liberties and stones assigned to them,
+  # groups can easily have 20+ stones and even more liberties, but that'd
+  # be even more setup :)
+  benchmark.report 'connecting two small groups' do
+    stones = [stone1, stone2]
+    my_stone = 44
+    group_tracker.dup.join_group_of_friendly_stones(stones, my_stone)
+  end
+
+  benchmark.report 'add_liberties' do
+    liberties = [24, 78, 36, 79]
+    group_tracker.add_liberties(liberties, stone1)
+  end
+
+  enemy_stones = [56, 34]
+  liberties = {
+    stone1 => stone1,
+    23 => Rubykon::Board::EMPTY,
+    73 => Rubykon::Board::EMPTY
+  }
+  enemy_group_1 = Rubykon::Group.new(enemy_stones[0], [enemy_stones[0]], liberties, 2)
+  enemy_group_2 = Rubykon::Group.new(enemy_stones[1], [enemy_stones[1]], liberties.dup, 2)
+  group_tracker.stone_to_group[enemy_stones[0]] = 3
+  group_tracker.groups[3] = enemy_group_1
+
+  group_tracker.stone_to_group[enemy_stones[1]] = 4
+  group_tracker.groups[4] = enemy_group_2
+
+
+  # Does not trigger enemy_group.caught? and removing the group.
+  # That doesn't happen THAT often and it'd require to setup an according
+  # board (with each test run)
+  benchmark.report 'remove liberties of enemies' do
+
+    group_tracker.dup.take_liberties_of_enemies(enemy_stones, stone1, game.board, :black)
+  end
+end