ruby-go 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 091a2ca59d5d27ee3f245c028892c85e397ad95c
+  data.tar.gz: 89446d73ed6b27a4ca938e287d51cda3e7b2489c
+SHA512:
+  metadata.gz: 8f69ca47e570e43b03f3079c4058f2dc37e8a201417d4ba47cd497216e43619312e3d5aa7fd60286740668a30ccde51d252358336db8b2434e2214385649ca9f
+  data.tar.gz: fc3d835f40595d18b13d06852daddd3c819d89437aa495cc999636e2669b1a956eaae542cefa7556c215f0976182f6530433fe2d2fd7f7f8efbe3a139be36046

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 John Hager
+
+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 OR COPYRIGHT HOLDERS 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/README.md

@@ -0,0 +1,16 @@
+Kata for the Game of Go
+=======================
+
+Objective
+---------
+Build a go game object with all functionality and uses TDD: 
+  * Can print the board  
+  * Can place a black/white stone on board  
+  * Cannot place a stone on top of another stone   
+  * Captures group of stones with no liberties   
+  * Keeps track of captures   
+  * Can undo all moves   
+  * Can pass   
+  * Keeps track of passes in a row (I.e. passes reset to 0 if a stone is played and subtract by 1 if it is undo)   
+  * Cannot place a suicide stone  
+  * Cannot capture a ko

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rake'
+
+task :default do 
+  Dir.glob('test/*_test.rb').each {|test| load test}
+end

data/bin/ruby-go.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/go'
+
+game = Game.new
+
+def game.prompt_for_turn
+  print "Pass or enter coordinates x, y for move (e.g. 4, 4): "
+  ans = gets.chomp.downcase.gsub(/\s/, '')
+
+  if ans =~ /pass/
+    self.pass 
+    nil
+  else
+    ans.split(',').collect {|c| Integer(c)}
+  end
+end 
+
+system "clear"
+game.view
+turn = 0
+until game.passes >= 2
+  begin 
+    if turn % 2 == 0
+      #black's turn
+      puts "Black's turn"
+      ans = game.prompt_for_turn
+      game.black(*ans) if ans
+    else
+      #white's turn 
+      puts "white's turn"
+      ans = game.prompt_for_turn 
+      game.white(*ans) if ans
+    end
+
+    system "clear"
+    game.view
+
+    turn += 1
+  rescue Game::IllegalMove
+    next
+  end
+end
+
+system "clear"

data/lib/board.rb

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,116 @@
+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.include?(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/go.rb

@@ -0,0 +1,5 @@
+require_relative 'board'
+require_relative 'game'
+require_relative 'stone'
+
+require 'sgf'

data/lib/stone.rb

@@ -0,0 +1,101 @@
+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

data/test/go_test.rb

@@ -0,0 +1,135 @@
+require_relative 'test_helper'
+require 'stringio'
+
+class GoTest < Minitest::Test 
+  def setup
+    b,w = Board::Colors[:black], Board::Colors[:white] 
+    e   = Board::Colors[:empty]
+
+    @row_9_str = "_ _ _ _ _ _ _ _ _\n" 
+
+    @game = Game.new(board: 9)
+  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_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_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
+
+  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_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_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_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
+
+  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
+
+

data/test/sgf_test.rb

@@ -0,0 +1,51 @@
+require_relative 'test_helper'
+
+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_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)
+
+    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 
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require_relative '../lib/go.rb'
+
+require 'minitest/autorun'

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: ruby-go
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- jphager2
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-07 00:00:00.000000000 Z
+dependencies: []
+description: A gem to play go and save games as sgf
+email: jphager2@gmail.com
+executables:
+- ruby-go.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- bin/ruby-go.rb
+- lib/board.rb
+- lib/game.rb
+- lib/go.rb
+- lib/stone.rb
+- test/go_test.rb
+- test/sgf_test.rb
+- test/test_helper.rb
+homepage: https://github.com/jphager2/ruby-go
+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.2.2
+signing_key: 
+specification_version: 4
+summary: The game of Go, writen in Ruby
+test_files: []