ruby-go 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74efecc082ec565b2ffa7c416f8a28497706c895
-  data.tar.gz: 5f702299cf817f5fc56d70910b225ecc92879fd8
+  metadata.gz: 99c7a4ed50ed990d7029979e84ff6c18338577f2
+  data.tar.gz: 12c6da43266d2267faae29bfe7b121589e5c85d7
 SHA512:
-  metadata.gz: 1531c446d300958152b41c69c0b05a8f503f90f0bdc35cd041e52f15db2370000971f1b3f2a83acc5a3097a789a4a324a2a3a344979ef1e9a9a0785db7e2a779
-  data.tar.gz: 50b2b336a5f64132537ad193a0efe1c1a17867757539a730272fbbe6b4231f87f2eab036fb38ac67531bfcbf20289c8acee094458e84a43c0e5599878b9548eb
+  metadata.gz: 7453628a08d3b1f1cf25e39fa2494eaeb085af2e1f986974467f2e51040c58ddd5a351e93fc363a4011cb0e3c9001aa0c48d918afc3a70ae52f299bcfb02dc0b
+  data.tar.gz: 79eaf22114887997f545b5877ab3dcd19bc801b9fc8dd4b9e96d039d83e81400959a86b10ba1fec87b259f4a1b48d02d71f2bd21a4713114520addf51223993f

data/lib/ruby-go/board.rb

@@ -0,0 +1,83 @@
+module RubyGo
+  class Board
+    Colors = {black: 'x', white: 'o', empty: '_'}
+
+    attr_accessor :board
+    def initialize(size)
+      @board = []
+      size -= 1
+
+      0.upto(size) do |y|
+        row = []
+        0.upto(size) do |x| 
+          row << Liberty.new(x, y) 
+        end
+        @board << row
+      end
+    end
+
+    def size
+      @board.length
+    end
+
+    def empty?
+      !@board.flatten.any? do |s| 
+        !s.empty?
+      end
+    end
+
+    def at(x, y)
+      @board[y][x]
+    end
+
+    def around(x, y = :y_not_given)
+      x, y = x.to_coord if x.kind_of?(Stone)
+      stones = [] 
+      stones << at(x-1, y) unless x == 0 
+      stones << at(x+1, y) unless x == (@board.length - 1) 
+      stones << at(x, y-1) unless y == 0 
+      stones << at(x, y+1) unless y == (@board.length - 1)
+      stones
+    end
+
+    def remove(stone)
+      stone.remove_from_board(self)
+    end
+
+    def place(stone)
+      stone.place_on_board(self)
+    end
+
+    def liberties(stone)
+      group_of(stone).inject(0) do |libs, stn|
+        libs + stn.liberties(self).count
+      end
+    end
+
+    def group_of(stone)
+      stone.group(self)
+    end
+
+    def to_str
+      out = ""
+      if @board.length < 11
+        out << "\s\s\s#{(0..@board.length - 1).to_a.join(' ')}\n" 
+      else
+        out                                << 
+          "\s\s\s#{(0..10).to_a.join(' ')}" <<
+          "#{(11..@board.length - 1).to_a.join('')}\n"
+      end
+
+      @board.each_with_index do |row, i|
+        i = "\s#{i}" if i < 10
+        out << "#{i}\s#{(row.collect {|stn| stn.to_s}).join(' ')}\n"
+      end
+
+      out
+    end
+
+    def to_s 
+      to_str
+    end
+  end
+end

data/lib/ruby-go/game.rb

@@ -0,0 +1,126 @@
+module RubyGo
+  class Game 
+
+    LETTERS = ('a'..'z').to_a
+
+    attr_reader :board
+    def initialize(board: 19)
+      @board = Board.new(board)
+      @moves = []
+    end
+
+    def save(name="my_go_game")
+      tree = SGF::Parser.new.parse(to_sgf)
+      tree.save(name + '.sgf')
+    end
+
+    def to_sgf
+      sgf = "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[#{board.size}]PW[White]PB[Black]"
+
+      @moves.each do |move|
+        sgf << move[:stone].to_sgf
+      end
+
+      sgf << ')'
+    end
+
+    def view 
+      puts  @board.to_s
+      puts  "   " + "_"*(@board.size * 2)
+      print "   Prisoners || White: #{captures[:black]} |"
+      puts  " Black: #{captures[:white]}"
+      puts  "   " + "-"*(@board.size * 2)
+    end
+
+    def black(x, y)
+      play(BlackStone.new(x,y))
+    end
+
+    def white(x, y)
+      play(WhiteStone.new(x,y))
+    end
+
+    def black_pass
+      pass(:black)
+    end
+
+    def white_pass
+      pass(:white)
+    end
+
+    def pass(color)
+      @moves << {stone: NullStone.new(color), captures: [], pass: true} 
+    end
+
+    def undo 
+      move = @moves.pop
+      @board.remove(move[:stone])
+      move[:captures].each {|stone| @board.place(stone)}
+    end
+
+    def passes
+      @moves.inject(0) {|total, move| move[:pass] ? total + 1 : 0}
+    end 
+
+    def captures
+      @moves.each_with_object({black: 0, white: 0}) do |move, total|
+        move[:captures].each do |capture|
+          total[capture.color] += 1
+        end
+      end
+    end 
+
+    private
+
+    def play(stone)
+      @board.place(stone)
+      @moves << {stone: stone, captures: [], pass: false}
+
+      capture; suicide; ko
+    end
+
+    def ko 
+      return if @moves.length < 2 or !@moves[-2][:captures] 
+
+      captures = @moves[-2][:captures]
+      stone = @moves.last[:stone]
+
+      if captures == [stone]
+        undo
+        raise IllegalMove, 
+          "You cannot capture the ko, play a ko threat first"
+      end
+    end
+
+    def suicide
+      stone = @moves.last[:stone]
+      unless @board.liberties(stone) > 0
+        undo
+        raise IllegalMove, "You cannot play a suicide."
+      end
+    end
+
+    def capture
+      stone = @moves.last[:stone]
+      stones_around = @board.around(stone)
+
+      captures = stones_around.select {|stn| @board.liberties(stn) == 0}
+
+      captures.each {|stone| capture_group(stone)}
+    end
+
+    def capture_group(stone)
+      @board.group_of(stone).each {|stone| capture_stone(stone)}
+    end
+
+    def capture_stone(stone)
+      @moves.last[:captures] << stone 
+      @board.remove(stone)
+    end
+
+    public
+
+    class IllegalMove < Exception
+    end
+  end
+end

data/lib/ruby-go/stone.rb

@@ -0,0 +1,104 @@
+module RubyGo
+  class Stone
+
+    attr_reader :color
+    def initialize(x, y)
+      @x, @y = x, y
+      @color = :none
+    end
+
+    def to_sgf
+      x = Game::LETTERS[@x]
+      y = Game::LETTERS[@y]
+      ";#{color.to_s[0].upcase}[#{x+y}]"
+    end
+
+    def empty?
+      @color == :empty
+    end
+
+    def place_on_board(board)
+      unless board.at(@x, @y).empty? 
+        raise Game::IllegalMove, 
+          "You cannot place a stone on top of another stone."  
+      end
+      board.board[@y][@x] = self
+    end
+
+    def remove_from_board(board)
+      board.board[@y][@x] = Liberty.new(*self.to_coord)
+    end
+
+    def liberties(board)
+      board.around(self).select {|stone| stone.empty?} 
+    end
+
+    def group(board, stones = [])
+      return stones if stones.any? {|stone| stone.eql?(self)} 
+      stones << self
+
+      board.around(self).each do |stone|
+        if stone.color == @color
+          stone.group(board, stones)
+        end
+      end
+
+      stones
+    end
+
+    def to_coord
+      [@x, @y]
+    end
+
+    def to_str
+      Board::Colors[@color] 
+    end
+
+    def to_s
+      to_str
+    end
+
+    def ==(other)
+      (self.color == other.color) and (self.to_coord == other.to_coord)
+    end
+  end
+
+  class Liberty < Stone 
+    def initialize(x, y)
+      super
+      @color = :empty
+    end
+
+    def liberties(board)
+      [self]
+    end
+  end
+
+  class BlackStone < Stone
+    def initialize(x, y)
+      super
+      @color = :black
+    end
+  end
+
+  class WhiteStone < Stone
+    def initialize(x, y)
+      super
+      @color = :white
+    end
+  end
+
+  class NullStone < Stone 
+    def initialize(color = :empty)
+      @x, @y = nil, nil
+      @color = color
+    end
+    
+    def remove_from_board(board)
+    end
+
+    def to_sgf
+      ";#{color.to_s[0].upcase}[]"
+    end
+  end
+end

data/lib/ruby-go/version.rb

@@ -0,0 +1,3 @@
+module RubyGo
+  VERSION = "0.2.0"
+end

data/lib/ruby-go.rb

@@ -1,5 +1,8 @@
-require_relative 'board'
-require_relative 'game'
-require_relative 'stone'
-
 require 'sgf'
+
+require_relative 'ruby-go/board'
+require_relative 'ruby-go/game'
+require_relative 'ruby-go/stone'
+
+module RubyGo
+end

data/test/go_test.rb

@@ -1,161 +1,165 @@
 require_relative 'test_helper'
 require 'stringio'
 
-class GoTest < Minitest::Test 
-  def setup
-    b,w = Board::Colors[:black], Board::Colors[:white] 
-    e   = Board::Colors[:empty]
+module RubyGo
+  class GoTest < Minitest::Test 
+    def setup
+      b,w = Board::Colors[:black], Board::Colors[:white] 
+      e   = Board::Colors[:empty]
 
-    @row_9_str = "_ _ _ _ _ _ _ _ _\n" 
+      @row_9_str = "_ _ _ _ _ _ _ _ _\n" 
 
-    @game = Game.new(board: 9)
-  end
+      @game = Game.new(board: 9)
+    end
 
-  def test_game_has_blank_board_when_initialized
-    assert @game.board.empty?
-  end
+    def test_game_has_blank_board_when_initialized
+      assert @game.board.empty?
+    end
 
-  def test_empty_board_looks_like_empty_board
-    assert_includes @game.board.to_s, @row_9_str 
-  end
+    def test_empty_board_looks_like_empty_board
+      assert_includes @game.board.to_s, @row_9_str 
+    end
 
-  def test_game_can_print_the_board
-    out = StringIO.new
-    temp = $stdout
-    $stdout = out
-    @game.view
-    $stdout = temp
-    out.rewind
-    assert_includes out.read, @row_9_str
-  end
+    def test_game_can_print_the_board
+      out = StringIO.new
+      temp = $stdout
+      $stdout = out
+      @game.view
+      $stdout = temp
+      out.rewind
+      assert_includes out.read, @row_9_str
+    end
 
-  def test_game_can_place_a_stone
-    game = Game.new(board: 9)
-    game.black(2,2)
-    assert_equal BlackStone.new(2,2), game.board.at(2,2) 
-  end
+    def test_game_can_place_a_stone
+      game = Game.new(board: 9)
+      game.black(2,2)
+      assert_equal BlackStone.new(2,2), game.board.at(2,2) 
+    end
 
-  def test_cannot_place_a_stone_on_top_of_another_stone
-    game = Game.new(board: 9)
-    game.black(2,2)
-    assert_raises(Game::IllegalMove) do
-      game.white(2,2)
+    def test_cannot_place_a_stone_on_top_of_another_stone
+      game = Game.new(board: 9)
+      game.black(2,2)
+      assert_raises(Game::IllegalMove) do
+        game.white(2,2)
+      end
     end
-  end
 
-  def test_can_capture_one_stone
-    game = Game.new(board: 9)
-    game.black(2,2)
-    game.white(2,1)
-    game.white(2,3)
-    game.white(1,2)
-    game.white(3,2)
-    assert_equal 1, game.captures[:black]
-  end
+    def test_can_capture_one_stone
+      game = Game.new(board: 9)
+      game.black(2,2)
+      game.white(2,1)
+      game.white(2,3)
+      game.white(1,2)
+      game.white(3,2)
+      assert_equal 1, game.captures[:black]
+    end
 
-  def test_capture_removes_stone
-    game = Game.new(board: 9)
-    game.black(2,2)
-    game.white(2,1)
-    game.white(2,3)
-    game.white(1,2)
-    game.white(3,2)
-    assert_equal Liberty.new(2,2), game.board.at(2,2) 
-  end
+    def test_capture_removes_stone
+      game = Game.new(board: 9)
+      game.black(2,2)
+      game.white(2,1)
+      game.white(2,3)
+      game.white(1,2)
+      game.white(3,2)
+      assert_equal Liberty.new(2,2), game.board.at(2,2) 
+    end
 
-  def test_capture_three_stones
-    game = Game.new(board: 9)
-    game.black(2,1)
-    game.black(2,2)
-    game.black(2,3)
-    game.white(2,0)
-    game.white(2,4)
-    game.white(1,1)
-    game.white(1,2)
-    game.white(1,3)
-    game.white(3,1)
-    game.white(3,2)
-    game.white(3,3)
-    assert_equal 3, game.captures[:black]
-  end
+    def test_capture_three_stones
+      game = Game.new(board: 9)
+      game.black(2,1)
+      game.black(2,2)
+      game.black(2,3)
+      game.white(2,0)
+      game.white(2,4)
+      game.white(1,1)
+      game.white(1,2)
+      game.white(1,3)
+      game.white(3,1)
+      game.white(3,2)
+      game.white(3,3)
+      assert_equal 3, game.captures[:black]
+    end
 
-  def test_can_undo
-    game = Game.new()
-    game.black(2,2)
-    game.white(2,3)
-    game.undo
-    assert_equal Liberty.new(2,3), game.board.at(2,3)
-  end
+    def test_can_undo
+      game = Game.new()
+      game.black(2,2)
+      game.white(2,3)
+      game.undo
+      assert_equal Liberty.new(2,3), game.board.at(2,3)
+    end
 
-  def test_can_undo_until_beginning
-    game = Game.new()
-    game.black(2,2)
-    game.white(3,2)
-    game.black(3,3)
-    3.times {game.undo}
-    assert_equal Liberty.new(2,2), game.board.at(2,2)
-  end
+    def test_can_undo_until_beginning
+      game = Game.new()
+      game.black(2,2)
+      game.white(3,2)
+      game.black(3,3)
+      3.times {game.undo}
+      assert_equal Liberty.new(2,2), game.board.at(2,2)
+    end
 
-  def test_can_pass
-    game = Game.new
-    game.pass 
-    game.pass
-    assert_equal 2, game.passes
-  end
+    def test_can_pass
+      game = Game.new
+      game.pass(:black)
+      game.pass(:white)
+      game.black_pass
+      game.white_pass
+      assert_equal 4, game.passes
+    end
 
-  def test_cannot_play_a_suicide
-    game = Game.new
-    game.black(3,3)
-    game.white(2,3)
-    game.white(4,3)
-    game.white(3,4)
-    game.white(3,2)
-    assert_raises(Game::IllegalMove) do
+    def test_cannot_play_a_suicide
+      game = Game.new
       game.black(3,3)
+      game.white(2,3)
+      game.white(4,3)
+      game.white(3,4)
+      game.white(3,2)
+      assert_raises(Game::IllegalMove) do
+        game.black(3,3)
+      end
     end
-  end
 
-  def test_cannot_play_a_ko
-    game = Game.new
-    game.black(3,3)
-    game.white(2,3)
-    game.white(4,3)
-    game.white(3,4)
-    game.white(3,2)
-    game.black(4,2)
-    game.black(4,4)
-    game.black(5,3)
-    game.black(3,3)
-    assert_raises(Game::IllegalMove) do
+    def test_cannot_play_a_ko
+      game = Game.new
+      game.black(3,3)
+      game.white(2,3)
       game.white(4,3)
+      game.white(3,4)
+      game.white(3,2)
+      game.black(4,2)
+      game.black(4,4)
+      game.black(5,3)
+      game.black(3,3)
+      assert_raises(Game::IllegalMove) do
+        game.white(4,3)
+      end
     end
-  end
 
-  def big_capture_area_game
-    game = Game.new
-    game.black(0,0)
-    game.white(1,1)
-    game.black(0,1)
-    game.white(0,2)
-    game.black(1,0)
-    game.white(2,0)
-    game
-  end
+    def big_capture_area_game
+      game = Game.new
+      game.black(0,0)
+      game.white(1,1)
+      game.black(0,1)
+      game.white(0,2)
+      game.black(1,0)
+      game.white(2,0)
+      game
+    end
 
-  def test_can_play_in_previous_capture_area_that_is_not_a_ko
-    game = big_capture_area_game
-    assert_equal Liberty.new(0,0), game.board.at(0,0) 
-    game.black(0,0)
-    assert_equal BlackStone.new(0,0), game.board.at(0,0) 
-
-    game = big_capture_area_game
-    assert_equal Liberty.new(0,1), game.board.at(0,1) 
-    game.black(0,1)
-    assert_equal BlackStone.new(0,1), game.board.at(0,1) 
-
-    game = big_capture_area_game
-    assert_equal Liberty.new(1,0), game.board.at(1,0) 
-    game.black(1,0)
-    assert_equal BlackStone.new(1,0), game.board.at(1,0) 
+    def test_can_play_in_previous_capture_area_that_is_not_a_ko
+      game = big_capture_area_game
+      assert_equal Liberty.new(0,0), game.board.at(0,0) 
+      game.black(0,0)
+      assert_equal BlackStone.new(0,0), game.board.at(0,0) 
+
+      game = big_capture_area_game
+      assert_equal Liberty.new(0,1), game.board.at(0,1) 
+      game.black(0,1)
+      assert_equal BlackStone.new(0,1), game.board.at(0,1) 
+
+      game = big_capture_area_game
+      assert_equal Liberty.new(1,0), game.board.at(1,0) 
+      game.black(1,0)
+      assert_equal BlackStone.new(1,0), game.board.at(1,0) 
+    end
   end
 end

data/test/sgf_test.rb

@@ -1,51 +1,52 @@
 require_relative 'test_helper'
 
-class SGFTest < Minitest::Test
+module RubyGo
+  class SGFTest < Minitest::Test
 
-  def test_game_converts_to_sgf
-    game = Game.new
-    assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black])",
-      game.to_sgf
-  end
+    def test_game_converts_to_sgf
+      game = Game.new
+      assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black])",
+        game.to_sgf
+    end
 
-  def test_game_converts_to_sgf_with_moves
-    game = Game.new
-    game.black(15,3)
-    game.white(3,3)
-    game.black(3,15)
-    game.white(15,15)
-    assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black];B[pd];W[dd];B[dp];W[pp])",
-      game.to_sgf
-  end
+    def test_game_converts_to_sgf_with_moves
+      game = Game.new
+      game.black(15,3)
+      game.white(3,3)
+      game.black(3,15)
+      game.white(15,15)
+      assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black];B[pd];W[dd];B[dp];W[pp])",
+        game.to_sgf
+    end
 
-  def test_game_converts_correctly_with_capture
-    game = Game.new
-    game.black(15,3)
-    game.white(16,3)
-    game.black(16,2)
-    game.white(15,2)
-    game.black(14,2)
-    game.white(14,3)
-    game.black(17,3)
-    game.white(15,4)
-    game.black(16,4)
-    game.white(15,3)
+    def test_game_converts_correctly_with_capture
+      game = Game.new
+      game.black(15,3)
+      game.white(16,3)
+      game.black(16,2)
+      game.white(15,2)
+      game.black(14,2)
+      game.white(14,3)
+      game.black(17,3)
+      game.white(15,4)
+      game.black(16,4)
+      game.white(15,3)
 
-    assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black];B[pd];W[qd];B[qc];W[pc];B[oc];W[od];B[rd];W[pe];B[qe];W[pd])",
-      game.to_sgf
-  end
+      assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black];B[pd];W[qd];B[qc];W[pc];B[oc];W[od];B[rd];W[pe];B[qe];W[pd])",
+        game.to_sgf
+    end
 
-  def test_saves_sgf
-    file = File.expand_path('../../my_go_game.sgf', __FILE__)
-    path = File.expand_path('../../*.sgf', __FILE__)
-    File.delete(file) if File.exist?(file)
-    game = Game.new
-    game.black(15,3)
-    game.white(16,3)
-    game.black(16,2)
-    game.white(15,2)
-    game.save
-    assert_includes Dir.glob(path), file 
+    def test_saves_sgf
+      file = File.expand_path('../../my_go_game.sgf', __FILE__)
+      path = File.expand_path('../../*.sgf', __FILE__)
+      File.delete(file) if File.exist?(file)
+      game = Game.new
+      game.black(15,3)
+      game.white(16,3)
+      game.black(16,2)
+      game.white(15,2)
+      game.save
+      assert_includes Dir.glob(path), file 
+    end
   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-go
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - jphager2
@@ -35,10 +35,11 @@ files:
 - README.md
 - Rakefile
 - bin/ruby-go.rb
-- lib/board.rb
-- lib/game.rb
 - lib/ruby-go.rb
-- lib/stone.rb
+- lib/ruby-go/board.rb
+- lib/ruby-go/game.rb
+- lib/ruby-go/stone.rb
+- lib/ruby-go/version.rb
 - test/go_test.rb
 - test/sgf_test.rb
 - test/test_helper.rb

data/lib/board.rb

@@ -1,82 +0,0 @@
-class Board
-  Colors = {black: 'x', white: 'o', empty: '_'}
-
-  attr_accessor :board
-  def initialize(size)
-    @board = []
-    size -= 1
-
-    0.upto(size) do |y|
-      row = []
-      0.upto(size) do |x| 
-        row << Liberty.new(x, y) 
-      end
-      @board << row
-    end
-  end
-
-  def size
-    @board.length
-  end
-
-  def empty?
-    !@board.flatten.any? do |s| 
-      !s.empty?
-    end
-  end
-
-  def at(x, y)
-    @board[y][x]
-  end
-
-  def around(x, y = :y_not_given)
-    x, y = x.to_coord if x.kind_of?(Stone)
-    stones = [] 
-    stones << at(x-1, y) unless x == 0 
-    stones << at(x+1, y) unless x == (@board.length - 1) 
-    stones << at(x, y-1) unless y == 0 
-    stones << at(x, y+1) unless y == (@board.length - 1)
-    stones
-  end
-
-  def remove(stone)
-    stone.remove_from_board(self)
-  end
-
-  def place(stone)
-    stone.place_on_board(self)
-  end
-
-  def liberties(stone)
-    group_of(stone).inject(0) do |libs, stn|
-      libs + stn.liberties(self).count
-    end
-  end
-
-  def group_of(stone)
-    stone.group(self)
-  end
-
-  def to_str
-    out = ""
-    if @board.length < 11
-      out << "\s\s\s#{(0..@board.length - 1).to_a.join(' ')}\n" 
-    else
-      out                                << 
-        "\s\s\s#{(0..10).to_a.join(' ')}" <<
-        "#{(11..@board.length - 1).to_a.join('')}\n"
-    end
-
-    @board.each_with_index do |row, i|
-      i = "\s#{i}" if i < 10
-      out << "#{i}\s#{(row.collect {|stn| stn.to_s}).join(' ')}\n"
-    end
-
-    out
-  end
-
-  def to_s 
-    to_str
-  end
-end
-

data/lib/game.rb

@@ -1,116 +0,0 @@
-class Game 
-
-  LETTERS = ('a'..'z').to_a
-
-  attr_reader :board
-  def initialize(board: 19)
-    @board = Board.new(board)
-    @moves = []
-  end
-
-  def save(name="my_go_game")
-    tree = SGF::Parser.new.parse(to_sgf)
-    tree.save(name + '.sgf')
-  end
-
-  def to_sgf
-    sgf = "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black]"
-
-    @moves.each do |move|
-      sgf << move[:stone].to_sgf
-    end
-
-    sgf << ')'
-  end
-
-  def view 
-    puts  @board.to_s
-    puts  "   " + "_"*(@board.size * 2)
-    print "   Prisoners || White: #{captures[:black]} |"
-    puts  " Black: #{captures[:white]}"
-    puts  "   " + "-"*(@board.size * 2)
-  end
-
-  def black(x, y)
-    play(BlackStone.new(x,y))
-  end
-
-  def white(x, y)
-    play(WhiteStone.new(x,y))
-  end
-
-  def pass
-    @moves << {stone: NullStone.new(), captures: [], pass: true} 
-  end
-
-  def undo 
-    move = @moves.pop
-    @board.remove(move[:stone])
-    move[:captures].each {|stone| @board.place(stone)}
-  end
-
-  def passes
-    @moves.inject(0) {|total, move| move[:pass] ? total + 1 : 0}
-  end 
-
-  def captures
-    @moves.each_with_object({black: 0, white: 0}) do |move, total|
-      move[:captures].each do |capture|
-        total[capture.color] += 1
-      end
-    end
-  end 
-
-  private
-    def play(stone)
-      @board.place(stone)
-      @moves << {stone: stone, captures: [], pass: false}
-
-      capture; suicide; ko
-    end
-
-    def ko 
-      return if @moves.length < 2 or !@moves[-2][:captures] 
-
-      captures = @moves[-2][:captures]
-      stone = @moves.last[:stone]
-
-      if captures == [stone]
-        undo
-        raise IllegalMove, 
-          "You cannot capture the ko, play a ko threat first"
-      end
-    end
-
-    def suicide
-      stone = @moves.last[:stone]
-      unless @board.liberties(stone) > 0
-        undo
-        raise IllegalMove, "You cannot play a suicide."
-      end
-    end
-
-    def capture
-      stone = @moves.last[:stone]
-      stones_around = @board.around(stone)
-
-      captures = stones_around.select {|stn| @board.liberties(stn) == 0}
-
-      captures.each {|stone| capture_group(stone)}
-    end
-
-    def capture_group(stone)
-      @board.group_of(stone).each {|stone| capture_stone(stone)}
-    end
-
-    def capture_stone(stone)
-      @moves.last[:captures] << stone 
-      @board.remove(stone)
-    end
-
-  public
-
-  class IllegalMove < Exception
-  end
-end
-

data/lib/stone.rb

@@ -1,101 +0,0 @@
-class Stone
-
-  attr_reader :color
-  def initialize(x, y)
-    @x, @y = x, y
-    @color = :none
-  end
-
-  def to_sgf
-    x = Game::LETTERS[@x]
-    y = Game::LETTERS[@y]
-    ";#{color.to_s[0].upcase}[#{x+y}]"
-  end
-
-  def empty?
-    @color == :empty
-  end
-
-  def place_on_board(board)
-    unless board.at(@x, @y).empty? 
-      raise Game::IllegalMove, 
-        "You cannot place a stone on top of another stone."  
-    end
-    board.board[@y][@x] = self
-  end
-
-  def remove_from_board(board)
-    board.board[@y][@x] = Liberty.new(*self.to_coord)
-  end
-
-  def liberties(board)
-    board.around(self).select {|stone| stone.empty?} 
-  end
-
-  def group(board, stones = [])
-    return stones if stones.any? {|stone| stone.eql?(self)} 
-    stones << self
-
-    board.around(self).each do |stone|
-      if stone.color == @color
-        stone.group(board, stones)
-      end
-    end
-
-    stones
-  end
-
-  def to_coord
-    [@x, @y]
-  end
-
-  def to_str
-    Board::Colors[@color] 
-  end
-
-  def to_s
-    to_str
-  end
-
-  def ==(other)
-    (self.color == other.color) and (self.to_coord == other.to_coord)
-  end
-end
-
-class Liberty < Stone 
-  def initialize(x, y)
-    super
-    @color = :empty
-  end
-
-  def liberties(board)
-    [self]
-  end
-end
-
-class BlackStone < Stone
-  def initialize(x, y)
-    super
-    @color = :black
-  end
-end
-
-class WhiteStone < Stone
-  def initialize(x, y)
-    super
-    @color = :white
-  end
-end
-
-class NullStone < Stone 
-  def initialize(*args)
-    @x, @y = nil, nil
-  end
-  
-  def remove_from_board(board)
-  end
-
-  def to_sfg
-    ""
-  end
-end