ruby-go 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99c7a4ed50ed990d7029979e84ff6c18338577f2
-  data.tar.gz: 12c6da43266d2267faae29bfe7b121589e5c85d7
+  metadata.gz: bf963b32b745df2c152b2c7b3f29e71292087deb
+  data.tar.gz: 071b6bb76e230e17b17d5e3dfd7e21f19b78adae
 SHA512:
-  metadata.gz: 7453628a08d3b1f1cf25e39fa2494eaeb085af2e1f986974467f2e51040c58ddd5a351e93fc363a4011cb0e3c9001aa0c48d918afc3a70ae52f299bcfb02dc0b
-  data.tar.gz: 79eaf22114887997f545b5877ab3dcd19bc801b9fc8dd4b9e96d039d83e81400959a86b10ba1fec87b259f4a1b48d02d71f2bd21a4713114520addf51223993f
+  metadata.gz: a16e13bc9751e9542bb4fb619a41a7ca6b45a0265148f627d20902e58a4a43fae580ed35ba674a94b43e082414f6f75f2a2227fcff2a438d7bdf8bbc12a5922e
+  data.tar.gz: d99a7e2ad8758315f11b49351820e91a5cffdcc138de51e858e51d142a5c3c66babe417f84549802002c88a6ec3cdfba6572f48eda30f35fabe03882e0ff02b3

data/bin/ruby-go.rb

@@ -2,7 +2,7 @@
 
 require_relative '../lib/ruby-go'
 
-game = Game.new
+game = RubyGo::Game.new
 
 def game.prompt_for_turn
   print "Pass or enter coordinates x, y for move (e.g. 4, 4): "
@@ -37,7 +37,7 @@ until game.passes >= 2
     game.view
 
     turn += 1
-  rescue Game::IllegalMove
+  rescue RubyGo::Game::IllegalMove
     next
   end
 end

data/lib/ruby-go.rb

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

data/lib/ruby-go/board.rb

@@ -1,83 +1,89 @@
 module RubyGo
   class Board
-    Colors = {black: 'x', white: 'o', empty: '_'}
+    COLORS = { black: 'x', white: 'o', empty: '_' }.freeze
+
+    attr_accessor :internal_board, :size
 
-    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
+      @internal_board = Array.new(size) { Array.new(size) { Liberty.new } }
+      @size = size
     end
 
-    def size
-      @board.length
-    end
+    private :internal_board
 
     def empty?
-      !@board.flatten.any? do |s| 
-        !s.empty?
-      end
+      internal_board.flatten.all?(&:empty?)
     end
 
     def at(x, y)
-      @board[y][x]
+      internal_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
+    def around(x, y)
+      intersections = []
+
+      intersections << at(x-1, y) unless x == 0
+      intersections << at(x+1, y) unless x == (internal_board.length - 1)
+      intersections << at(x, y-1) unless y == 0
+      intersections << at(x, y+1) unless y == (internal_board.length - 1)
+      intersections
     end
 
     def remove(stone)
-      stone.remove_from_board(self)
+      return if stone.empty?
+
+      x, y = stone.to_coord
+
+      internal_board[y][x] = Liberty.new
     end
 
+    # Board shouldn't care about game rules
     def place(stone)
-      stone.place_on_board(self)
+      x, y = stone.to_coord
+
+      internal_board[y][x] = stone
     end
 
     def liberties(stone)
-      group_of(stone).inject(0) do |libs, stn|
-        libs + stn.liberties(self).count
+      libs = []
+
+      group_of(stone).each do |stn|
+        libs += around(*stn.to_coord).select(&:empty?)
       end
+
+      libs.uniq.length
     end
 
-    def group_of(stone)
-      stone.group(self)
+    def group_of(stone, stones = [])
+      return stones if stones.include?(stone)
+
+      stones << stone
+
+      around(*stone.to_coord).each do |intersection|
+        next if intersection.empty?
+
+        group_of(intersection, stones) if intersection.color == stone.color
+      end
+
+      stones
     end
 
-    def to_str
+    def to_s
       out = ""
-      if @board.length < 11
-        out << "\s\s\s#{(0..@board.length - 1).to_a.join(' ')}\n" 
+      
+      if size < 11
+        out << "\s\s\s#{(0..size - 1).to_a.join(' ')}\n" 
       else
-        out                                << 
-          "\s\s\s#{(0..10).to_a.join(' ')}" <<
-          "#{(11..@board.length - 1).to_a.join('')}\n"
+        out << "\s\s\s#{(0..10).to_a.join(' ')}" 
+        out << "#{(11..size - 1).to_a.join('')}\n"
       end
 
-      @board.each_with_index do |row, i|
+      internal_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

@@ -1,14 +1,14 @@
 module RubyGo
-  class Game 
+  class Game
+    attr_reader :board, :moves
 
-    LETTERS = ('a'..'z').to_a
-
-    attr_reader :board
     def initialize(board: 19)
       @board = Board.new(board)
-      @moves = []
+      @moves = Moves.new
     end
 
+    private :moves
+
     def save(name="my_go_game")
       tree = SGF::Parser.new.parse(to_sgf)
       tree.save(name + '.sgf')
@@ -17,27 +17,27 @@ module RubyGo
     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
+      moves.each do |move|
+        sgf << move.played.to_sgf
       end
 
       sgf << ')'
     end
 
     def view 
-      puts  @board.to_s
-      puts  "   " + "_"*(@board.size * 2)
+      puts  board
+      puts  "   " + "_"*(board.size * 2)
       print "   Prisoners || White: #{captures[:black]} |"
       puts  " Black: #{captures[:white]}"
-      puts  "   " + "-"*(@board.size * 2)
+      puts  "   " + "-"*(board.size * 2)
     end
 
     def black(x, y)
-      play(BlackStone.new(x,y))
+      play(Stone.new(x, y, :black))
     end
 
     def white(x, y)
-      play(WhiteStone.new(x,y))
+      play(Stone.new(x, y, :white))
     end
 
     def black_pass
@@ -48,79 +48,85 @@ module RubyGo
       pass(:white)
     end
 
-    def pass(color)
-      @moves << {stone: NullStone.new(color), captures: [], pass: true} 
-    end
+    def undo
+      move = moves.pop
 
-    def undo 
-      move = @moves.pop
-      @board.remove(move[:stone])
-      move[:captures].each {|stone| @board.place(stone)}
+      board.remove(move.played)
+      move.captures.each do |stone|
+        board.place(stone)
+      end
     end
 
     def passes
-      @moves.inject(0) {|total, move| move[:pass] ? total + 1 : 0}
-    end 
+      moves.pass_count
+    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 
+      moves.capture_count
+    end
 
     private
 
+    def pass(color)
+      moves.pass(NullStone.new(color))
+    end
+
     def play(stone)
-      @board.place(stone)
-      @moves << {stone: stone, captures: [], pass: false}
+      check_illegal_placement!(stone)
+
+      board.place(stone)
+      moves.play(stone)
+      record_captures!(stone)
 
-      capture; suicide; ko
+      check_illegal_suicide!(stone)
+      check_illegal_ko!(stone)
     end
 
-    def ko 
-      return if @moves.length < 2 or !@moves[-2][:captures] 
+    def check_illegal_placement!(stone)
+      unless board.at(*stone.to_coord).empty? 
+        raise(
+          Game::IllegalMove, 
+          "You cannot place a stone on top of another stone."  
+        )
+      end
+    end
 
-      captures = @moves[-2][:captures]
-      stone = @moves.last[:stone]
+    def check_illegal_ko!(stone)
+      last_move = moves.prev
 
-      if captures == [stone]
+      return unless last_move
+
+      if last_move.captures == [stone] && moves.current.captures.one?
         undo
-        raise IllegalMove, 
+        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
+    def check_illegal_suicide!(stone)
+      if board.liberties(stone).zero?
         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}
+    def record_captures!(stone)
+      stones_around = board.around(*stone.to_coord).reject(&:empty?)
 
-      captures.each {|stone| capture_group(stone)}
-    end
+      captures = stones_around
+                   .reject {| stn| stn.color == stone.color }
+                   .select { |stn| @board.liberties(stn).zero? }
 
-    def capture_group(stone)
-      @board.group_of(stone).each {|stone| capture_stone(stone)}
+      captures.map {|stone| @board.group_of(stone)}
+        .flatten.uniq.each {|stone| capture_stone(stone)}
     end
 
     def capture_stone(stone)
-      @moves.last[:captures] << stone 
-      @board.remove(stone)
+      moves.capture(stone)
+      board.remove(stone)
     end
 
-    public
-
-    class IllegalMove < Exception
+    class IllegalMove < StandardError
     end
   end
 end

data/lib/ruby-go/liberty.rb

@@ -0,0 +1,11 @@
+module RubyGo
+  class Liberty
+    def empty?
+      true
+    end
+
+    def to_s
+      Board::COLORS[:empty] 
+    end
+  end
+end

data/lib/ruby-go/moves.rb

@@ -0,0 +1,63 @@
+module RubyGo
+  class Moves
+    attr_reader :internal_moves, :capture_count, :pass_count
+
+    def initialize
+      @internal_moves = []
+      @pass_count = 0
+      @capture_count = { black: 0, white: 0 }
+    end
+
+    def play(played)
+      @pass_count += 0
+      internal_moves << Move.new(played)
+    end
+
+    def pass(pass)
+      @pass_count += 1
+      internal_moves << Move.new(pass)
+    end
+
+    def each(&block)
+      internal_moves.each(&block)
+    end
+
+    def prev
+      internal_moves[-2]
+    end
+
+    def current
+      internal_moves[-1]
+    end
+
+    def pop
+      move = internal_moves.pop
+
+      move.captures.each do |stone|
+        capture_count[stone.color] -= 1
+      end
+
+      @pass_count -= 1 if move.empty?
+
+      move
+    end
+
+    def capture(stone)
+      current.captures << stone
+      capture_count[stone.color] += 1
+    end
+  end
+
+  class Move
+    attr_reader :played, :captures
+
+    def initialize(played)
+      @played = played
+      @captures = []
+    end
+
+    def empty?
+      played.empty?
+    end
+  end
+end

data/lib/ruby-go/stone.rb

@@ -1,104 +1,54 @@
 module RubyGo
   class Stone
+    LETTERS = ('a'..'z').to_a
 
-    attr_reader :color
-    def initialize(x, y)
-      @x, @y = x, y
-      @color = :none
+    attr_reader :color, :x_coord, :y_coord
+
+    def initialize(x_coord, y_coord, color)
+      @x_coord = x_coord
+      @y_coord = y_coord 
+      @color = color
     end
 
     def to_sgf
-      x = Game::LETTERS[@x]
-      y = Game::LETTERS[@y]
-      ";#{color.to_s[0].upcase}[#{x+y}]"
+      x = LETTERS[x_coord]
+      y = LETTERS[y_coord]
+      ";#{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
+      false
     end
 
     def to_coord
-      [@x, @y]
-    end
-
-    def to_str
-      Board::Colors[@color] 
+      [x_coord, y_coord]
     end
 
     def to_s
-      to_str
+      Board::COLORS[color] 
     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
+      other.is_a?(Stone) &&
+        (color == other.color) &&
+        (to_coord == other.to_coord)
     end
   end
 
+  # This can be changed to a Pass object
   class NullStone < Stone 
     def initialize(color = :empty)
-      @x, @y = nil, nil
+      @x_coord = nil
+      @y_coord = nil
       @color = color
     end
-    
-    def remove_from_board(board)
-    end
 
     def to_sgf
       ";#{color.to_s[0].upcase}[]"
     end
+    
+    def empty?
+      true
+    end
   end
 end

data/lib/ruby-go/version.rb

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

data/test/go_test.rb

@@ -2,12 +2,12 @@ require_relative 'test_helper'
 require 'stringio'
 
 module RubyGo
-  class GoTest < Minitest::Test 
+  class GoTest < Minitest::Test
     def setup
-      b,w = Board::Colors[:black], Board::Colors[:white] 
-      e   = Board::Colors[:empty]
+      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
@@ -17,7 +17,7 @@ module RubyGo
     end
 
     def test_empty_board_looks_like_empty_board
-      assert_includes @game.board.to_s, @row_9_str 
+      assert_includes @game.board.to_s, @row_9_str
     end
 
     def test_game_can_print_the_board
@@ -33,7 +33,7 @@ module RubyGo
     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) 
+      assert_equal :black, game.board.at(2,2).color
     end
 
     def test_cannot_place_a_stone_on_top_of_another_stone
@@ -61,7 +61,7 @@ module RubyGo
       game.white(2,3)
       game.white(1,2)
       game.white(3,2)
-      assert_equal Liberty.new(2,2), game.board.at(2,2) 
+      assert game.board.at(2,2).empty?
     end
 
     def test_capture_three_stones
@@ -80,12 +80,41 @@ module RubyGo
       assert_equal 3, game.captures[:black]
     end
 
+    def test_snap_back
+      game = Game.new(board: 9)
+      game.black(3,2)
+      game.black(2,3)
+      game.black(4,3)
+      game.black(2,4)
+      game.black(5,4)
+      game.black(3,5)
+      game.black(4,5)
+      game.white(4,2)
+      game.white(5,3)
+      game.white(3,4)
+      game.white(4,4)
+      game.white(3,3)
+      assert_equal 1, game.captures[:black]
+      assert_equal 0, game.captures[:white]
+      game.black(4,3)
+      assert_equal 1, game.captures[:black]
+      assert_equal 3, game.captures[:white]
+    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)
+      assert game.board.at(2,3).empty?
+    end
+
+    def test_can_undo_pass
+      game = Game.new
+      game.black(2,2)
+      game.white_pass
+      game.undo
+      assert_equal 0, game.passes
     end
 
     def test_can_undo_until_beginning
@@ -94,16 +123,14 @@ module RubyGo
       game.white(3,2)
       game.black(3,3)
       3.times {game.undo}
-      assert_equal Liberty.new(2,2), game.board.at(2,2)
+      assert game.board.at(2,2).empty?
     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
+      assert_equal 2, game.passes
     end
 
     def test_cannot_play_a_suicide
@@ -147,19 +174,19 @@ module RubyGo
 
     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) 
+      assert game.board.at(0,0).empty?
       game.black(0,0)
-      assert_equal BlackStone.new(0,0), game.board.at(0,0) 
+      assert_equal :black, game.board.at(0,0).color
 
       game = big_capture_area_game
-      assert_equal Liberty.new(0,1), game.board.at(0,1) 
+      assert game.board.at(0,1).empty?
       game.black(0,1)
-      assert_equal BlackStone.new(0,1), game.board.at(0,1) 
+      assert_equal :black, game.board.at(0,1).color
 
       game = big_capture_area_game
-      assert_equal Liberty.new(1,0), game.board.at(1,0) 
+      assert game.board.at(1,0).empty?
       game.black(1,0)
-      assert_equal BlackStone.new(1,0), game.board.at(1,0) 
+      assert_equal :black, game.board.at(1,0).color
     end
   end
 end

data/test/sgf_test.rb

@@ -46,7 +46,7 @@ module RubyGo
       game.black(16,2)
       game.white(15,2)
       game.save
-      assert_includes Dir.glob(path), file 
+      assert_includes Dir.glob(path), file
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-go
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - jphager2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-11 00:00:00.000000000 Z
+date: 2017-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: SgfParser
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 3.0.0
 description: A gem to play go and save games as sgf
 email: jphager2@gmail.com
 executables:
@@ -38,6 +38,8 @@ files:
 - lib/ruby-go.rb
 - lib/ruby-go/board.rb
 - lib/ruby-go/game.rb
+- lib/ruby-go/liberty.rb
+- lib/ruby-go/moves.rb
 - lib/ruby-go/stone.rb
 - lib/ruby-go/version.rb
 - test/go_test.rb
@@ -63,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: The game of Go, writen in Ruby