tak 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 81e9a8abccf6d37f5e596c350591f2a525f31f3e
-  data.tar.gz: b2691c0cba1a8b48e056e018c2c04975da2751dc
+SHA256:
+  metadata.gz: 3bc109da83ba6396965054bc21ede3b5a6dbc18d32f888470a99c1d86153d426
+  data.tar.gz: de8afe399c579542ccc04cb51662971ea0b76266bd6decdd56dbdb49122d2a9f
 SHA512:
-  metadata.gz: a16b8e60677e841d70d6f2d1c1a4ff1d8eb8f2ed28009c3a620843bdc00570577a373df03781fabff22cd9f23f676e5795844fdd1822d14351b16c823af79b3a
-  data.tar.gz: 4aef0aee1fc4ef45e21a5a921bbad10fba0e804d91f42437e081289b7ab94be17e24dcc5265378ae6c329a721d9d98e9db08a464254ad5cc451f0126aa7fff2a
+  metadata.gz: 456cfc6b766ea9f636cef4c22ea87baaa0fb56c26074fd44ee4043620202cba785d1a6e3c4d63b3e30f200efbd1a1b031a772af11ff784254bc24ae2e2358249
+  data.tar.gz: 46248cdf495efd2aef8b53e2ebe587101844292c6cc59ec70ddac0e7f243c8fc9527316364f4c447234c3589b468cb29a868e6d99c55fc17451a1e2e0413bc5b

data/.gitignore

@@ -1,9 +1,9 @@
 /.bundle/
 /.yardoc
-/Gemfile.lock
 /_yardoc/
 /coverage/
 /doc/
 /pkg/
 /spec/reports/
 /tmp/
+/*.gem

data/Gemfile

@@ -2,3 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in tak.gemspec
 gemspec
+
+gem 'guard'
+gem 'guard-rspec'

data/Gemfile.lock

@@ -0,0 +1,71 @@
+PATH
+  remote: .
+  specs:
+    tak (0.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.3)
+    diff-lcs (1.4.4)
+    ffi (1.15.0)
+    formatador (0.2.5)
+    guard (2.16.2)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    listen (3.4.1)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    lumberjack (1.2.8)
+    method_source (1.0.0)
+    nenv (0.3.0)
+    notiffany (0.1.3)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.14.0)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (10.5.0)
+    rb-fsevent (0.10.4)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    shellany (0.0.1)
+    thor (1.1.0)
+
+PLATFORMS
+  x86_64-darwin-19
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  guard
+  guard-rspec
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  tak!
+
+BUNDLED WITH
+   2.2.3

data/Guardfile

@@ -0,0 +1,42 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/README.md

@@ -1,38 +1,14 @@
 # Tak
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/tak`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'tak'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install tak
+Ruby Tak utilities and gameplay helpers
 
 ## Usage
 
-TODO: Write usage instructions here
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+TBD
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/tak. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/baweaver/tak. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 
 ## License

data/Rakefile

@@ -4,3 +4,38 @@ require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
+
+require "bundler/gem_tasks"
+
+# http://blog.zachallett.com/pry-reload/
+#
+# I should gemify this later.
+task :console do
+  require 'pry'
+  require 'tak'
+
+  # http://stackoverflow.com/questions/9236264/how-to-disable-warning-for-redefining-a-constant-when-loading-a-file
+  def silence_warnings(&block)
+    warn_level, $VERBOSE = $VERBOSE, nil
+
+    result   = block.call
+    $VERBOSE = warn_level
+
+    result
+  end
+
+  # Modified a bit to silence some constant reload warnings
+  # and to return a true or the error.
+  def reload!
+    !!silence_warnings do
+      $LOADED_FEATURES
+        .select { |feat| feat =~ /\/tak\// }
+        .each { |file| load file }
+    end
+  rescue => e
+    e
+  end
+
+  ARGV.clear
+  Pry.start
+end

data/lib/tak.rb

@@ -3,3 +3,9 @@ require "tak/version"
 module Tak
   # Your code goes here...
 end
+
+require 'tak/ptn'
+require 'tak/board'
+require 'tak/piece_set'
+require 'tak/player'
+require 'tak/move'

data/lib/tak/board.rb

@@ -0,0 +1,267 @@
+module Tak
+  class Board
+    attr_accessor :size
+    attr_accessor :board
+
+    attr_reader :white_piece_set
+    attr_reader :black_piece_set
+
+    # What constitutes a road-forming piece
+    ROAD = {
+      white: %w(w Cw),
+      black: %w(b Cb)
+    }
+
+    # Creates a new Tak Board
+    #
+    # @param size [Integer]       Size of the board
+    # @param ptn  [Array[String]] Previous game moveset to reconstruct from
+    def initialize(size, ptn = nil)
+      @size  = size
+      @board = generate_board(ptn)
+
+      @white_piece_set = Tak::PieceSet.new(board_size: size)
+      @black_piece_set = Tak::PieceSet.new(board_size: size)
+
+      @piece_sets = {
+        white: white_piece_set,
+        black: black_piece_set
+      }
+    end
+
+    # Gets the current visible flat counts on the board
+    #
+    # @return [Hash[Symbol, Integer]]
+    def flat_counts
+      count_hash = Hash.new { |h,k| h[k] = 0 }
+
+      @board.each_with_object(count_hash) do |row, counts|
+        row.each do |cell|
+          counts[:white] += 1 if cell.last == 'w'
+          counts[:black] += 1 if cell.last == 'b'
+        end
+      end
+    end
+
+    # Checks to see if any piece sets are empty
+    #
+    # @return [Boolean]
+    def empty_piece_set?
+      @piece_sets.any? { |c, piece_set| piece_set.empty? }
+    end
+
+    # Returns who the flat winner is, or false if there is none yet
+    #
+    # Not a fan of the Bool/Sym response, consider refactor later.
+    #
+    # @return [Boolean || Symbol]
+    def flat_winner
+      return false unless empty_piece_set?
+
+      white_flats, black_flats = flat_counts.values
+      case white_flats <=> black_flats
+      when  0 then :tie
+      when  1 then :white
+      when -1 then :black
+      end
+    end
+
+    # Converts the current board into a bit variant in which viable
+    # road pieces for `color` are represented as 1s
+    #
+    # @param color [Symbol]
+    #
+    # @return [Array[Array[Integer]]]
+    def bit_board(color)
+      @board.map { |row|
+        row.map { |cell| ROAD[color].include?(cell.last) ? 1 : 0 }
+      }
+    end
+
+    # Checks if a road win for `color` is present
+    #
+    # @param color [Symbol] Color to check for a win
+    #
+    # @return [Boolean]
+    def road_win?(color)
+      current_bit_board = bit_board(color)
+
+      # Begin traversing through the board for potential roads.
+      path_search(0, 0, nil, current_bit_board) || !!@size.times.find { |n|
+        path_search(1, n, :horizontal, current_bit_board) ||
+        path_search(n, 1, :vertical, current_bit_board)
+      }
+    end
+
+    # Checks which color player currently owns a square
+    #
+    # @param x [Integer]
+    # @param y [Integer]
+    #
+    # @return [Symbol]
+    def square_owner(x, y)
+      return true if @board[x][y].empty?
+
+      @board[x][y].last == 'b' ? :black : :white
+    end
+
+    # Retrieves the pieces present at a coordinate
+    #
+    # @param x [Integer]
+    # @param y [Integer]
+    #
+    # @return [Array[String]]
+    def pieces_at(x, y)
+      @board[x][y]
+    end
+
+    # Moves pieces according to PTN notation
+    #
+    # @param ptn [String]
+    #   String representation of a Tak move
+    #
+    # @param color [Symbol]
+    #   Which player is making the move
+    #
+    # @return [Boolean]
+    #   Success status
+    def move!(ptn, color)
+      move = Tak::Move.new(ptn, self, color)
+
+      return false unless move.valid? && square_owner(*move.origin)
+
+      case move.type
+      when 'movement'
+        distribute_pieces(move)
+      when 'placement'
+        place_piece(move, color)
+      end
+    end
+
+    # Distributes pieces from a stack move across the board
+    #
+    # @param move [Tak::Move]
+    #
+    # @return [Boolean]
+    def distribute_pieces(move)
+      stack = pieces_at(*move.origin).pop(move.size)
+
+      move.coordinates.each do |(x, y)|
+        @board[x][y].push(stack.pop)
+      end
+
+      true
+    end
+
+    # Places a piece at a given move coordinate
+    #
+    # @param move [Tak::Move]
+    # @param color [Symbol]
+    #
+    # @return [Boolean]
+    #   Success of placement
+    def place_piece(move, color)
+      square = pieces_at(*move.origin)
+
+      return false unless square.empty? && @piece_sets[color].remove(move.piece_type)
+
+      square.push(move.piece)
+
+      true
+    end
+
+    # Consider moving this all out into a board formatter later. It'd be cleaner.
+    #
+    # May Matz forgive me for my debugging code here.
+    def to_s
+      max_size = board.flatten(1).max.join(' ').size + 1
+
+      counts = flat_counts.map { |c, i|
+        set = @piece_sets[c]
+        "#{c}: #{i} flats, #{set.flats} remaining pieces, #{set.capstones} remaining capstones"
+      }.join("\n")
+
+      board_state = board.reverse.map.with_index { |row, i|
+        row_head = "  #{size - i} "
+
+        row_head + row.map { |cell|
+          "[%#{max_size}s]" % cell.join(' ')
+        }.join(' ')
+      }.join("\n")
+
+      footer = ('a'..'h').take(size).map { |c| "%#{max_size + 2}s" % c }.join(' ')
+
+      "#{counts}\n\n#{board_state}\n   #{footer}"
+    end
+
+    private
+
+    # Checks whether a given coordinate pair is out of bounds
+    #
+    # @param x [Integer]
+    # @param y [Integer]
+    #
+    # @return [Boolean]
+    def out_of_bounds?(x,y)
+      x < 0 || y < 0 || x > @size - 1 || y > @size - 1
+    end
+
+    # Does a DFS variant to locate a potential road.
+    #
+    # @param x         [Integer] Start X coordinate
+    # @param y         [Integer] Start Y coordinate
+    # @param direction [Symbol]  Direction the search completes on
+    #
+    # @param bit_board [Array[Array[Integer]]] Board to parse against
+    # @param traversed [Array[Array[Boolean]]] Traversal tracker
+    #
+    # @return [Boolean] Whether or not a road was round
+    def path_search(x, y, direction, bit_board, traversed = visited_board)
+      return false if out_of_bounds?(x,y) || traversed[x][y]
+
+      piece_value = bit_board[x][y]
+      return false if piece_value == 0 # Non-road piece
+      return true  if road_end?(direction, x, y)
+
+      traversed[x][y] = true
+
+      # Recurse in all four directions. While this may retrace steps it is
+      # necessary as roads in Tak can curve wildly.
+      path_search(x + 1, y,     direction, bit_board, traversed) ||
+      path_search(x - 1, y,     direction, bit_board, traversed) ||
+      path_search(x,     y + 1, direction, bit_board, traversed) ||
+      path_search(x,     y - 1, direction, bit_board, traversed)
+    end
+
+    # Checks to see if a given x y coordinate pair is counted as a road win
+    # by being on the appropriate opposite end from the starting direction
+    # of the road.
+    #
+    # @param direction [Symbol]  Starting direction of the road
+    # @param x         [Integer]
+    # @param y         [Integer]
+    #
+    # @return [Boolean]
+    def road_end?(direction, x, y)
+      case direction
+      when :horizontal
+        x == @size - 1
+      when :vertical
+        y == @size - 1
+      else
+        x == @size - 1 || y == @size - 1
+      end
+    end
+
+    # Creates a board to mark previous traversals of the path search
+    #
+    # @return [Array[Array[Boolean]]]
+    def visited_board
+      Array.new(@size) { Array.new(@size, false) }
+    end
+
+    def generate_board(ptn)
+      return Array.new(size) { Array.new(size) { [] } } unless ptn
+    end
+  end
+end

data/lib/tak/game.rb

@@ -0,0 +1,9 @@
+module Tak
+  class Game
+    def initialize(size)
+      @tak_board  = Tak::Board.new(size)
+      @turn       = :white
+      @first_move = true
+    end
+  end
+end

data/lib/tak/move.rb

@@ -0,0 +1,69 @@
+module Tak
+  class Move
+    attr_reader :move
+    attr_reader :origin
+
+    # Pieces that get in the way of a road
+    OBSTRUCTIONS = %w(Cw Cb Sw Sb)
+
+    def initialize(ptn, tak_board, color)
+      @move   = Tak::PTN.new(ptn, tak_board.size)
+      @board  = tak_board.board
+      @origin = [@move.x, @move.y]
+      @color  = color.to_s[0]
+    end
+
+    def type
+      move.type
+    end
+
+    def piece_type
+      case piece
+      when /C/ then :capstone
+      when /S/ then :standing
+      else :flatstone
+      end
+    end
+
+    def piece
+      "#{move.special_piece}#{@color}"
+    end
+
+    def valid?
+      return true unless obstructed?
+      return false if coordinates.flatten.any? { |n|
+        n > @board.size || n < 0
+      }
+
+      x, y      = move.position
+      top_piece = @board[x][y].last
+
+      if %w(Cw Cb).include?(top_piece)
+        x2, y2      = coordinates.last
+        obstruction = @board[x2][y2].last
+
+        %w(Sw Sb).include?(obstruction)
+      else
+        false
+      end
+    end
+
+    def obstructed?
+      !!coordinates.find { |(x,y)| OBSTRUCTIONS.include?(@board[x][y].last) }
+    end
+
+    def coordinates
+      x, y  = move.position
+      times = move.size.times
+
+      return [[x,y]] if move.size.zero?
+
+      case move.direction
+      when '+' then times.map { |n| [x,     y + n] }
+      when '-' then times.map { |n| [x,     y - n] }
+      when '<' then times.map { |n| [x - n, y]     }
+      when '>' then times.map { |n| [x + n, y + n] }
+      end
+    end
+  end
+end

data/lib/tak/piece_set.rb

@@ -0,0 +1,58 @@
+module Tak
+  class PieceSet
+    attr_reader :flats, :capstones
+
+    # https://en.wikipedia.org/wiki/Tak_(game)#Rules
+    #
+    # 21 pieces is correct for 5s
+    #
+    # size => [pieces, capstones]
+    PIECE_TOTALS = {
+      3 => [10, 0],
+      4 => [15, 0],
+      5 => [21, 1],
+      6 => [30, 1],
+      7 => [40, 2],
+      8 => [50, 2]
+    }
+
+    def initialize(board_size: 5, flats: nil, capstones: nil)
+      default_flats, default_capstones = PIECE_TOTALS[board_size]
+
+      @flats     = flats || default_flats
+      @capstones = capstones || default_capstones
+
+      @pieces = {
+        capstone:  @capstones,
+        flatstone: @flats
+      }
+    end
+
+    # Whether or not the set is empty
+    #
+    # @note It's often forgotten rule that a capstone needs to be played to
+    #       consider a piece set as empty and trigger a flat win count.
+    #
+    # @return [Boolean]
+    def empty?
+      @capstones + @flats == 0
+    end
+
+    # Removes a piece from a set
+    #
+    # @param type [Symbol] Type of piece
+    #
+    # @return [Boolean] Whether the removal was valid
+    def remove(type)
+      return false if @pieces[type] - 1 < 0
+
+      if type == :capstone
+        @capstones -= 1
+      else
+        @flats -= 1
+      end
+
+      true
+    end
+  end
+end

data/lib/tak/player.rb

@@ -0,0 +1,8 @@
+module Tak
+  class Player
+    def initialize(name, color)
+      @name  = name
+      @color = color
+    end
+  end
+end

data/lib/tak/ptn.rb

@@ -0,0 +1,155 @@
+module Tak
+  class PTN
+    NOTATION_REGEX = /
+      (?<number>\d+)?
+      (?<special_piece>[CS])?
+      (?<position>[a-h][1-8])
+      (
+        (?<direction>[<>+-])
+        (?<stack>\d+)?
+      )?
+    /xi
+
+    KTN_SPECIAL_TO_PTN = {
+      'C' => 'C',
+      'W' => 'S',
+      nil => ''
+    }
+
+    KTN_PLACEMENT = 'P'
+    KTN_MOVEMENT  = 'M'
+
+    PTN_NORTH = '+'
+    PTN_SOUTH = '-'
+    PTN_RIGHT = '>'
+    PTN_LEFT  = '<'
+
+    attr_reader :errors, :ptn_match, :direction, :special_piece
+
+    def initialize(notation, board_size = 5)
+      @ptn_match  = NOTATION_REGEX.match(notation)
+      @board_size = board_size
+      @notation   = notation
+
+      if @ptn_match
+        @number        = @ptn_match[:number]
+        @special_piece = @ptn_match[:special_piece]
+        @position      = @ptn_match[:position]
+        @direction     = @ptn_match[:direction]
+        @stack         = @ptn_match[:stack]
+      end
+
+      @errors = []
+    end
+
+    def to_s
+      "#{@number}#{@special_piece}#{@position}#{@direction}#{@stack}"
+    end
+
+    def type
+      @direction ? 'movement' : 'placement'
+    end
+
+    def position
+      [x, y]
+    end
+
+    def y
+      alpha_range[@position.chars.first] - 1
+    end
+
+    def x
+      @position.chars.last.to_i - 1
+    end
+
+    def stack_total
+      @stack_total ||= @stack ? @stack.chars.sum(&:to_i) : 0
+    end
+
+    def size
+      stack_total
+    end
+
+    def error(msg)
+      @errors << msg
+    end
+
+    # Placement of a special piece (Capstone or Standing) cannot also be a move
+    def movement_and_placement?
+      !!(@special_piece && @number || @direction || @stack)
+    end
+
+    def over_stack?
+      stack_total > @number.to_i
+    end
+
+    def under_stack?
+      stack_total < @number.to_i
+    end
+
+    def above_handsize?
+      stack_total > @board_size || @number.to_i > @board_size
+    end
+
+    def out_of_bounds?
+      x > @board_size || y.to_i > @board_size
+    end
+
+    def distrubutes_out_of_bounds?
+      x + stack_total > @board_size ||
+      y.to_i + stack_total > @board_size
+    end
+
+    def valid?
+      @valid ||= begin
+        # Break before we do anything else here.
+        error 'Did not match PTN Format' and return false unless @ptn_match
+
+        error 'Cannot move more pieces than the board size!'      if above_handsize?
+        error 'Cannot distribute more pieces than were picked up' if over_stack?
+        error 'Cannot distribute less pieces than were picked up' if under_stack?
+        error 'Cannot move and place a piece'                     if movement_and_placement?
+        error 'Cannot place or move a piece out of bounds'        if out_of_bounds?
+        error 'Cannot distribute pieces out of bounds'            if distrubutes_out_of_bounds?
+
+        @errors.none?
+      end
+    end
+
+    def alpha_range
+      @alpha_range ||= ('a'..'h').each.with_index(1).zip.flatten(1).to_h
+    end
+
+    def self.from_ktn(move)
+      move_type, *remainder = move.split(' ')
+
+      ptn_string =
+        case move_type
+        when KTN_PLACEMENT
+          square, special_piece = remainder
+          stone = KTN_SPECIAL_TO_PTN[special_piece]
+
+          "#{stone}#{square.downcase}"
+        when KTN_MOVEMENT
+          from_square, to_square, *distribution = remainder
+
+          from_square_col, from_square_row = from_square.chars
+          to_square_col,   to_square_row   = to_square.chars
+
+          direction = if from_square_col == to_square_col
+            to_square_row > from_square_row ? PTN_NORTH : PTN_SOUTH
+          else
+            to_square_col > from_square_col ? PTN_RIGHT : PTN_LEFT
+          end
+
+          hand_size = distribution.map(&:to_i).sum
+
+          "#{hand_size}#{from_square.downcase}#{direction}#{distribution.join}"
+        else
+          ''
+        end
+
+      new(ptn_string)
+    end
+  end
+end

data/lib/tak/version.rb

@@ -1,3 +1,3 @@
 module Tak
-  VERSION = "0.0.0"
+  VERSION = "0.0.1"
 end

data/tak.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tak
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Brandon Weaver
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2017-02-07 00:00:00.000000000 Z
+date: 2021-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -64,19 +64,27 @@ files:
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
 - lib/tak.rb
+- lib/tak/board.rb
+- lib/tak/game.rb
+- lib/tak/move.rb
+- lib/tak/piece_set.rb
+- lib/tak/player.rb
+- lib/tak/ptn.rb
 - lib/tak/version.rb
 - tak.gemspec
 homepage: https://github.com/baweaver/tak
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -91,9 +99,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Tak is a Tak board and ruleset handler
 test_files: []