gorb 0.0.1

data/README

@@ -0,0 +1,6 @@
+gorb is a go (board game) library written in pure Ruby.
+
+To use it, do the following:
+
+    gem build gorb.gemspec
+    gem install gorb-0.0.1.gem

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake'
+require 'rake/testtask'
+
+task :default => [:test]
+
+desc "Run tests"
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/test_*.rb'
+  t.verbose = false
+  t.warning = true
+end

data/lib/gorb.rb

@@ -0,0 +1,4 @@
+require 'gorb/board'
+require 'gorb/group'
+require 'gorb/player'
+require 'gorb/stone'

data/lib/gorb/board.rb

@@ -0,0 +1,147 @@
+require 'gorb/stone'
+
+class Board
+
+  attr_accessor :groups, :turn
+  attr_reader :black, :white, :handicap, :komi, :size
+
+  # Initialize a new Board instance. Requires two Player objects and a
+  # handicap as arguments. The handicap should be an integer from 0 to 9.
+  def initialize(black=nil, white=nil, handicap=0, komi=6.5, size="19x19")
+    @black = black ||= Player.new("Black")
+    @white = white ||= Player.new("White")
+    @komi = komi
+    @size = size
+    @groups = []
+    @hashes = []
+    @turn = black
+
+    raise ArgumentError, "Incorrect handicap" if handicap < 0 or handicap > 9
+    @handicap = handicap
+    @komi = 0.5 if handicap > 0
+    @turn = white if handicap > 1
+
+    if size == "9x9"
+      handicap_stones = %w{G7 C3 G3 C7 E5 C5 G5 E7 E3}
+    elsif size == "13x13"
+      handicap_stones = %w{K10 D4 K4 D10 G7 D7 K7 G10 G4}
+    elsif size == "19x19"
+      handicap_stones = %w{Q16 D4 Q4 D16 K10 D10 Q10 K16 K4}
+    else
+      raise ArgumentError, "Incorrect board size"
+    end
+
+    case @handicap
+    when 2..5, 7, 9
+      handicap_stones[0..(@handicap-1)].each {|s| self.add_stone(s, :black)}
+    when 6, 8
+      handicap_stones[0..@handicap].each {|s| self.add_stone(s, :black)}
+      self.remove_stone(handicap_stones[4]) # Middle stone
+    end
+  end
+
+  # Add a Stone to the board if the move is legal. This function will also
+  # keep track of the turn. You can force the color with additional color
+  # argument -- in this case the turn is not changing.
+  def add_stone(point, color=nil)
+    # Guess the color based on turn, unless color was forced.
+    unless color
+      if @turn == black
+        color = :black
+      else
+        color = :white
+      end
+      advance = true
+    end
+
+    # Check the legality of the move and play it if legal.
+    raise ArgumentError, "Illegal move" unless legal?(point, color)
+    stone = Stone.new(self, point, color)
+    resolve!(stone)
+
+    # If the color was not explicitly set, advance the turn.
+    turn_over if advance
+    return stone
+  end
+
+  def remove_stone(point)
+    stone = self.search(point).first
+    raise ArgumentError, "No such stone" unless stone
+    stone.group.delete(stone)
+    stone.board.groups.delete(stone.group) if stone.group.size == 0
+  end
+
+  # Search the Board for stones in given points.
+  def search(points)
+    stones = []
+    @groups.each do |group|
+      group.each do |stone|
+        stones << stone if points.include? stone.point
+      end
+    end
+    return stones
+  end
+
+  def stone_at?(point)
+    @groups.any? {|group| group.include? point}
+  end
+
+  def stones_at?(points)
+    points.all? {|point| self.stone_at? point}
+  end
+
+  # Recalculate all liberties. Removes dead groups from the table.
+  def resolve!(added_stone)
+    @groups.each do |group|
+      group.liberties! if not group.include? added_stone
+    end
+    # The group of last added stone is checked after others to make kills by
+    # 'suicide' (filling dame) work.
+    added_stone.group.liberties!
+  end
+
+  # Generate a hash of a board situation. Used to enforce ko rule.
+  def generate_hash
+    @groups.flatten.inject([]) {|hash, stone| hash << stone.to_s}.sort.hash
+  end
+
+  def legal?(point, color)
+    # Check if the point if already occupied.
+    return false if self.stone_at? point
+
+    # The method for checking legality requires placing a test stone to the
+    # point and seeing what happens. This is done by doing a deep copy of the
+    # board and playing the move there.
+    dummy_board = Marshal.load(Marshal.dump(self))
+
+    # Check for suicide.
+    stone = Stone.new(dummy_board, point, color)
+    legal = true
+    if stone.group.liberties == 0
+      # Normally suicide is not ok...
+      legal = false
+      # ...but killing with 'suicide' (filling dame) is ok.
+      opposing = dummy_board.search(stone.neighbors)
+      opposing.each do |opp_stone|
+        if opp_stone.color != color and opp_stone.group.liberties == 0
+          legal = true
+        end
+      end
+    end
+
+    # Check for ko.
+    dummy_board.resolve!(stone)
+    legal = false if @hashes.include? dummy_board.generate_hash
+    return legal
+  end
+
+  def turn_over
+    if @turn == @black
+      @turn = @white
+    else
+      @turn = @black
+    end
+    @hashes << generate_hash
+  end
+
+end

data/lib/gorb/group.rb

@@ -0,0 +1,42 @@
+class Group < Array
+
+  def initialize(board, stone)
+    @board = board
+    @board.groups << self
+    self << stone
+  end
+
+  def merge(groups)
+    groups.each do |group|
+      group.each {|stone| self << stone}
+      @board.groups.delete group
+    end
+  end
+
+  def include?(point)
+    self.any? {|stone| stone.point == point}
+  end
+
+  # Check the liberties of the Group.
+  def liberties
+    libs = []
+    self.each do |stone|
+      stone.liberties.each do |liberty|
+        libs << liberty
+      end
+    end
+    libs.uniq!
+    return libs.size
+  end
+
+  # Destructive version of the former. Note that this will remove the Group
+  # from the board if it has no liberties, so all the existing groups should
+  # have their liberties checked before checking the liberties of a new group
+  # in order to allow kills by filling dame.
+  def liberties!
+    libs = self.liberties
+    @board.groups.delete(self) if libs == 0
+    return libs
+  end
+
+end

data/lib/gorb/player.rb

@@ -0,0 +1,12 @@
+class Player
+
+  def initialize(name="Anonymous", rank=nil)
+    @name = name
+    @rank = rank
+  end
+
+  def to_str
+    @name
+  end
+
+end

data/lib/gorb/stone.rb

@@ -0,0 +1,80 @@
+require 'gorb/group'
+
+class Stone
+
+  attr_accessor :group
+  attr_reader :board, :point, :color
+
+  def initialize(board, point, color)
+    @board = board
+    @point = point
+    @color = color
+
+    if @board.size == "9x9"
+      @letters = %w{A B C D E F G H J}
+    elsif @board.size == "13x13"
+      @letters = %w{A B C D E F G H J K L M N}
+    elsif @board.size == "19x19"
+      @letters = %w{A B C D E F G H J K L M N O P Q R S T}
+    end
+
+    if (@point[1, 2].to_i > @board.size.split('x')[0].to_i or
+        not @letters.index(@point[0]))
+      raise ArgumentError, "Invalid point"
+    end
+
+    @group = self.find_group
+  end
+
+  # Return the neighboring points of the Stone.
+  def neighbors
+    x, y = @letters.index(@point[0]), @point[1, 2].to_i
+    neighbors = []
+    unless y == 1
+      neighbors << @letters[x] + (y - 1).to_s
+    end
+    unless y == @board.size.split('x')[0].to_i
+      neighbors << @letters[x] + (y + 1).to_s
+    end
+    unless @letters[x] == @letters.first
+      neighbors << @letters[x-1] + y.to_s
+    end
+    unless @letters[x] == @letters.last
+      neighbors << @letters[x+1] + y.to_s
+    end
+    return neighbors
+  end
+
+  # Return the liberties of the Stone.
+  def liberties
+    liberties = neighbors
+    stones = @board.search(neighbors)
+    stones.each {|stone| liberties.delete(stone.point)}
+    return liberties
+  end
+
+  # Find the Group of the Stone or create a new one. If this Stone connects
+  # one or more groups, merge them together to a single Group.
+  def find_group
+    groups = []
+    stones = @board.search(neighbors)
+    stones.each do |stone|
+      if stone.color == @color and not groups.include? stone.group
+        groups << stone.group
+      end
+    end
+    if groups.empty?
+      return Group.new(@board, self)
+    else
+      group = groups.pop
+      group.merge(groups)
+      group << self
+      return group
+    end
+  end
+
+  def to_s
+    @point
+  end
+
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: gorb
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Aku Kotkavuo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-06 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: gorb is a go (board game) library written in pure Ruby.
+email: aku@hibana.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/gorb/board.rb
+- lib/gorb/group.rb
+- lib/gorb/player.rb
+- lib/gorb/stone.rb
+- lib/gorb.rb
+- README
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/arkx/gorb
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby go library
+test_files: []
+