ruby-go 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8f24b07ee968e8a121f825d7c64e615649b8379e
-  data.tar.gz: 647b951b33b4394a657ddb1a749b8677ad6497c7
+SHA256:
+  metadata.gz: '024418870e37d715d73c1ce299b3db4c59b231d8fea65b64870e280b9f439387'
+  data.tar.gz: 460d7dbde08c15c6aec3e067dcd50c11d1b2dfac31cd708a97826a3b7b585ad1
 SHA512:
-  metadata.gz: 365788568b669d24207f3e52c604cf218f5c4e6228ec1316b5847a8e9ceadfd25f2f03807cfba0fc5793c79e88fbceffc3559b471e69c9762c43a7382ca401bb
-  data.tar.gz: b0c4e34d1cf9482e68322dcc3e9f6bc7b47ae1a6952baa4c7ac47b047599082ccddd05e677f3ec4fd62aa12bf76a4f52e21a8dbbd3b390fd59f80fecc475bf43
+  metadata.gz: b2871316ce937e2df59f6ec8b912b51bb20cc1b37c3d257e3ddb6be0067f559d7a18feb6d8e292955257d910cfacb36aab945794912f61438d036c0d561269b3
+  data.tar.gz: bba3a81eac11819591ff71683b413a9679d06e15fc3334b3e874e415ec25886a600272e783f98495a578722ad8fc4c4514089e954cd2bdf73d6046c8e3836555

data/README.md

@@ -1,16 +1,30 @@
-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
+# Ruby Go
+
+A gem that implements the rules of go (igo, weiqi, baduk).
+
+## Use
+
+```
+game = RubyGo::Game(board: 19)
+game.place_black(3,3)
+game.place_white(15,15)
+
+# ...
+
+game.pass_black
+game.pass_white
+```
+
+### Printers
+
+There are a few printers included in the gem, including `TextPrinter` and `HTMLPrinter`.
+
+The printer takes an `IO` like object, and can print the game.
+```
+printer = RubyGo::TextPrinter.new($stdout)
+printer.print_game(game)
+```
+
+### rubygo Command Line Interface
+
+The rubygo executable included in the gem is CLI that plays the game of go.

data/bin/rubygo

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'ruby-go'
+require 'ruby-go/printers/text'
+
+game = RubyGo::Game.new
+printer = RubyGo::TextPrinter.new($stdout)
+
+Signal.trap("INTERUPT") do
+  puts "\nGoodbye"
+  exit 1
+end
+
+def prompt_for_turn(game)
+  loop do
+    print 'Enter "Pass" or enter coordinates x, y for move (e.g. "4, 4"): '
+    ans = gets.chomp.downcase.gsub(/\s/, '')
+
+    return if ans =~ /pass/
+
+    return ans.split(',').collect {|c| Integer(c)} if ans =~/\d+,\d+/
+  end
+end
+
+def update_terminal(printer, game)
+  system "clear"
+  printer.print_game(game)
+end
+
+update_terminal(printer, game)
+
+turn = 0
+until game.passes >= 2
+  begin
+    if turn % 2 == 0
+      #black's turn
+      puts "Black's turn"
+      move = prompt_for_turn(game)
+      move ? game.place_black(*move) : game.black_pass
+    else
+      #white's turn
+      puts "White's turn"
+      move = prompt_for_turn(game)
+      move ? game.place_white(*move) : game.white_pass
+    end
+
+    update_terminal(printer, game)
+
+    turn += 1
+  rescue RubyGo::Game::IllegalMove => e
+    puts e.message
+    next
+  end
+end
+
+puts "Game over"

data/lib/ruby-go.rb

@@ -1,5 +1,10 @@
-require_relative 'board'
-require_relative 'game'
-require_relative 'stone'
-
 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'
+
+module RubyGo
+end

data/lib/ruby-go/board.rb

@@ -0,0 +1,66 @@
+module RubyGo
+  class Board
+    attr_reader :rows, :size
+
+    def initialize(size)
+      @rows = Array.new(size) { Array.new(size) { Liberty.new } }
+      @size = size
+    end
+
+    def empty?
+      rows.flatten.all?(&:empty?)
+    end
+
+    def at(x, y)
+      rows[y][x]
+    end
+
+    def around(x, y)
+      intersections = []
+
+      intersections << at(x-1, y) unless x == 0
+      intersections << at(x+1, y) unless x == (size - 1)
+      intersections << at(x, y-1) unless y == 0
+      intersections << at(x, y+1) unless y == (size - 1)
+      intersections
+    end
+
+    def remove(stone)
+      return if stone.empty?
+
+      x, y = stone.to_coord
+
+      rows[y][x] = Liberty.new
+    end
+
+    def place(stone)
+      x, y = stone.to_coord
+
+      rows[y][x] = stone
+    end
+
+    def liberties(stone)
+      libs = []
+
+      group_of(stone).each do |stn|
+        libs += around(*stn.to_coord).select(&:empty?)
+      end
+
+      libs.uniq.length
+    end
+
+    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
+  end
+end

data/lib/ruby-go/game.rb

@@ -0,0 +1,135 @@
+module RubyGo
+  class Game
+    attr_reader :board, :moves
+
+    def initialize(board: 19)
+      @board = Board.new(board)
+      @moves = Moves.new
+    end
+
+    private :moves
+
+    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.played.to_sgf
+      end
+
+      sgf << ')'
+    end
+
+    def place_black(x, y)
+      play(Stone.new(x, y, :black))
+    end
+
+    def place_white(x, y)
+      play(Stone.new(x, y, :white))
+    end
+
+    def black_pass
+      pass(:black)
+    end
+
+    def white_pass
+      pass(:white)
+    end
+
+    def undo
+      move = moves.pop
+
+      board.remove(move.played)
+      move.captures.each do |stone|
+        board.place(stone)
+      end
+    end
+
+    def passes
+      moves.pass_count
+    end
+
+    def captures
+      moves.capture_count
+    end
+
+    private
+
+    def pass(color)
+      moves.pass(NullStone.new(color))
+    end
+
+    def play(stone)
+      check_illegal_placement!(stone)
+
+      board.place(stone)
+      moves.play(stone)
+      record_captures!(stone)
+
+      check_illegal_suicide!(stone)
+      check_illegal_ko!(stone)
+    end
+
+    def check_illegal_placement!(stone)
+      coord = stone.to_coord
+
+      if coord.any? { |i| i < 0 || i >= board.size }
+        raise(
+          Game::IllegalMove,
+          "You cannot place a stone off the board."
+        )
+      end
+
+      intersection = board.at(*coord)
+
+      unless intersection.empty?
+        raise(
+          Game::IllegalMove,
+          "You cannot place a stone on top of another stone."
+        )
+      end
+    end
+
+    def check_illegal_ko!(stone)
+      last_move = moves.prev
+
+      return unless last_move
+
+      if last_move.captures == [stone] && moves.current.captures.one?
+        undo
+        raise IllegalMove,
+          "You cannot capture the ko, play a ko threat first"
+      end
+    end
+
+    def check_illegal_suicide!(stone)
+      if board.liberties(stone).zero?
+        undo
+        raise IllegalMove, "You cannot play a suicide."
+      end
+    end
+
+    def record_captures!(stone)
+      stones_around = board.around(*stone.to_coord).reject(&:empty?)
+
+      captures = stones_around
+                   .reject {| stn| stn.color == stone.color }
+                   .select { |stn| @board.liberties(stn).zero? }
+
+      captures.map {|stone| @board.group_of(stone)}
+        .flatten.uniq.each {|stone| capture_stone(stone)}
+    end
+
+    def capture_stone(stone)
+      moves.capture(stone)
+      board.remove(stone)
+    end
+
+    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 color
+      :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/printers/html.rb

@@ -0,0 +1,76 @@
+require 'erb'
+
+module RubyGo
+  class HTMLPrinter
+    LETTERS = ('A'..'Z').to_a.freeze
+    COLORS = { black: 'black stone', white: 'white stone', empty: 'liberty' }.freeze
+    TEMPLATE = ERB.new(<<~ERB).freeze
+      <style>
+      .board { max-width: 100%; padding: 16px; }
+      .row { display: flex; margin: 0; }
+      .intersection { display: inline-block; height: 32px; width: 32px; border-top: 2px solid black; border-left: 2px solid black; }
+      .intersection:last-child { border-top-width: 0px; height: 34px; }
+      .row:last-child .intersection { border-left-width: 0px; width: 34px; }
+      .row:last-child .intersection:last-child { width: 2px; height: 2px; background: black; }
+      .stone, .liberty { display: inline-block; width: 30px; height: 30px; border-radius: 100%; margin: 0; position: relative; top: -18px; left: -18px; }
+      .stone { border: 2px solid black; }
+      .black.stone { background: black; }
+      .white.stone { background: white; }
+      .liberty:hover { border: 2px solid red; }
+      .row-num, .column-num { display: inline-block; width: 34px; height: 34px; margin: 0; position: relative; }
+      .row-num { top: -0.5em; }
+      .column-num { left: -0.3em; }
+      </style>
+      <div class="game">
+        <div class="board">
+          <div class="row">
+            <div class="column-num row-num"></div>
+            <% size.times do |i| %>
+            <div class="column-num"><%= letters[i] %></div>
+            <% end %>
+          </div>
+          <% rows.each_with_index do |row, i| %>
+          <div class="row">
+            <div class="row-num"><%= letters[i] %></div>
+            <% row.each do |stn| %>
+              <div class="intersection">
+                <div class="<%= colors[stn.color] %>"></div>
+              </div>
+            <% end %>
+          </div>
+          <% end %>
+        </div>
+
+        <div class="info">
+          <table>
+            <tbody>
+              <tr>
+                <th>Prisoners</th>
+                <th>White</th>
+                <td><%= captures[:black] %></td>
+                <th>Black</th>
+                <td><%= captures[:white] %></td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    ERB
+
+    attr_reader :io
+
+    def initialize(io)
+      @io = io
+    end
+
+    def print_game(game)
+      html = TEMPLATE.result_with_hash(
+        size: game.board.size,
+        captures: game.captures,
+        rows: game.board.rows,
+        colors: COLORS, letters: LETTERS
+      )
+      io.write(html)
+    end
+  end
+end