gameboard 3.5.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76a2c121404f3a2b813bfea13c03ee703bf80cdc
-  data.tar.gz: 87fed90228c76fd036d1dbba598be427e77bfe25
+  metadata.gz: a2ca6f9592b619a43214ddc04663d93b3ef7206d
+  data.tar.gz: a0d06dad2b4044952a95580f84043faa7f54cc64
 SHA512:
-  metadata.gz: 260a7d4efc6d7f8fbe6106a912743177727ecfc722edde0a51c9e79f5ef3c18eb8f9296b654e2bb1f3b56890c2086108a57c340261efd6da3a5f64bde56098e6
-  data.tar.gz: 1929e29c05557e9cc156d2cc85429586b135fad9ecbff8208b877a1cbc6a969e99d15bfa94b78fd34f86476fa04ba109a3845eff39d476f06d34821deba73bd7
+  metadata.gz: 093e50a3af3a3cd74f2e7518d8712205c1f457bba00534f718220f6e49f6721f42fdb86c571cdd53f0c74fae53184a0bbb085f148677ccae74e706a49f437d8f
+  data.tar.gz: 5b8e24283506264ec88edad80e8c826006461c42f8d7c2ac0a7a323db1e8a46cb1a6e8dbec3905b27074771f02428390d4f6a35587a120036b76543a7fb537dc

data/bin/preview

@@ -10,10 +10,10 @@ class ShowOff
     #        ["A", "B", "C"],
     #        ["X", "Y", "Z"]
     #       ]
-    board = Board.new(height: 8, width: 10, cells: "O")
+    board = Board.new(height: 8, width: 10, cell_value: "O")
     # board = Board.new(preset: set)
     Render::clear
-    Render::board(board.horizontal)
+    Render::board(board.to_val(:horizontal))
   end
 end
 

data/lib/gameboard/board.rb

@@ -14,20 +14,20 @@ module Gameboard
 
     # Public: Initialize a gameboard.
     #
-    # height - The number of horizontal rows on the gameboard. Not passing a
-    #          height will raise an ArgumentError unless a preset board is
-    #          passed
-    # width  - The number of columns on the gameboard. Not passing a
-    #          width will raise an ArgumentError unless a preset board is
-    #          passed
-    # cells  - An optional value, preferably a String in most cases, that
-    #          changes the default cell value.
-    # preset - An optional 2D Array to load a preset gameboard. Saved games
-    #          should be created in rows from the top down.
+    # height      - The number of horizontal rows on the gameboard. Not
+    #               passing a height will raise an ArgumentError unless a
+    #               preset board is passed.
+    # width       - The number of columns on the gameboard. Not passing a
+    #               width will raise an ArgumentError unless a preset board
+    #               is passed.
+    # cell_value  - An optional value, preferably a String in most cases,
+    #               that changes the default cell value.
+    # preset -      An optional 2D Array to load a preset gameboard. Saved
+    #               games should be created in rows from the top down.
     #
     # Examples
     #
-    #   board = Board.new(cells: "O", width: 10, height: 8)
+    #   board = Board.new(cell_value: "O", width: 10, height: 8)
     #   # =>     -----------------------------------------
     #          0 | O | O | O | O | O | O | O | O | O | O |
     #            -----------------------------------------
@@ -65,12 +65,12 @@ module Gameboard
     #                   - 0 - 1 - 2 -
     #
     #
-    def initialize(height:false, width: false, cells: false, preset: false)
+    def initialize(height: nil, width: nil, cell_value: nil, preset: false)
       raise ArgumentError unless ((height.is_a?(Integer) && width.is_a?(Integer)) || !!preset)
       @height = height
       @width = width
       @nailed = false
-      @cells = cells || nil
+      @default_cell = cell_value
       preset ? load_game(preset) : new_board
     end
 
@@ -95,7 +95,7 @@ module Gameboard
       board
     end
 
-    # Public: An enumerator that yields each cells value.
+    # Public: An enumerator that yields each cell's value.
     # Example
     #
     #   board.each_value { |cell| p cell }
@@ -105,28 +105,28 @@ module Gameboard
     #
     def each_value(&block)
       return enum_for(__method__) if block.nil?
-      each{|cell| yield(cell.value)}
+      each{|cell| yield(cell.val)}
     end
 
-    # Public: An enumerator that yields each cells coordinates.
+    # Public: An enumerator that yields each cell's coordinates.
     # Example
     #
     #   board.each { |cell| p cell }
-    #     #=> [0, 0]
-    #     #=> [1, 0]
-    #     #=> [2, 0]
-    #     #=> [0, 1]
-    #     #=> [1, 1]...
+    #     #=> Coordinate (.position == [0, 0])
+    #     #=> Coordinate (.position == [1, 0])
+    #     #=> Coordinate (.position == [2, 0])
+    #     #=> Coordinate (.position == [0, 1])
+    #     #=> Coordinate (.position == [1, 1])...
     #
     def each_coordinate(&block)
       return enum_for(__method__) if block.nil?
-      each { |cell| yield(cell.coord.position) }
+      each { |cell| yield(cell.coord) }
     end
 
     # Public: Return the value of the next available point given a coordinate
     #         and a slope.
     #
-    # point  - The starting coordinate pair.
+    # point  - The starting point. [x, y] coordinate
     # slope  - An [x, y] slope (e.g. [1,1] means over one row, up one column).
     #          It must be an integer.
     # coords - An optional boolean to specify returning a coordinate pair
@@ -148,15 +148,14 @@ module Gameboard
     #   delta([0,0], [2, 1])
     #     #=> C ([2,1] if coord argument given)
     #
-    def delta(point, slope, coords = false)
-      delta =  point.zip(slope).map {|point| point.reduce(:+) }
-      piece = board.find { |cell| cell.coord.position == delta }
-      raise "Off Grid" unless !!piece
-      coords ? piece.coord.position : piece.value
+    def delta(point, slope)
+      base = find_cell(point)
+      find_cell(base.coord.send(:delta, slope))
     end
 
-    # Public: Return every diagonal on the gameboard. It does not require a
-    #         square board to function.
+    # Public: Return an Array of Gameboard::Cell for every diagonal on the gameboard. It does not
+    #         require a square board to function. Run #to_val(:diagonal) if you only need the
+    #         values at each index
     #
     # coords: An optional boolean to specify returning an Array of coordinates
     #         instead of values.
@@ -179,37 +178,26 @@ module Gameboard
     #          ["Y", "C"], [2, "C"], ["Z"], [3]
     #         ]
     #
-    #   diagonal(true)
-    #     #=> [
-    #          [[0, 0], [1, 1], [2, 2]],
-    #          [[0, 2], [1, 1], [2, 0]],
-    #          [[0, 1], [1, 2]],
-    #          [[0, 1], [1, 0]],
-    #          [[0, 2]],
-    #          [[0, 0]],
-    #          [[1, 0], [2, 1]],
-    #          [[1, 2], [2, 1]],
-    #          [[2, 0]],
-    #          [[2, 2]]
-    #         ]
+    #     #=> Note: Values above are for demonstration. Each value will actually be a
+    #               Gameboard::Cell with methods #coord and #val
+    #
     #
-    def diagonal(coords = false)
+    def diagonal
       diagonals = []
 
       height.times do |i|
-        diagonals << get_diagonal([0, i], coords)
-        diagonals << get_diagonal([0, height - 1 - i], coords, false)
+        diagonals << get_diagonal([0, i])
+        diagonals << get_diagonal([0, height - 1 - i], -1)
       end
-      (1...width).each do
-        |i| diagonals << get_diagonal([i, 0], coords)
-        diagonals << get_diagonal([i, height - 1], coords, false)
+      (1...width).each do |i|
+        diagonals << get_diagonal([i, 0])
+        diagonals << get_diagonal([i, height - 1], -1)
       end
-
       diagonals
     end
 
     def empty?
-      board.all? { |cell| cell.value == cells  }
+      board.all? { |cell| cell.val == default_cell  }
     end
 
     # Public: Find a cell at given coordinate.
@@ -245,7 +233,7 @@ module Gameboard
     #
     def flip
       raise "The Board is Nailed to the Table" unless !nailed_down?
-      board.each {|cell| cell.value = cells}
+      board.each {|cell| cell.val = default_cell}
     end
 
     # Public: Check if the gameboard is full relative to the default cell.
@@ -267,19 +255,19 @@ module Gameboard
     #   full?
     #     #=> true
     #
-    #   Board.new(height: 3, width: 3, cells: "Y")
+    #   Board.new(height: 3, width: 3, default: "Y")
     #
     #   full?
     #     #=> false (because our default piece is now "Y")
     #
     def full?
-      board.none? { |cell| cell.value == cells  }
+      board.none? { |cell| cell.val == default_cell  }
     end
 
-    # Public: Return every row on the gameboard.
+    # Public: Return every row on the gameboard. Run #to_val(:horizontal) if you only need the
+    #         values at each index
+    #
     #
-    # coords: An optional boolean to specify returning an Array of coordinates
-    #         instead of values.
     #
     # Example
     #      -------------
@@ -299,19 +287,13 @@ module Gameboard
     #          [1, 2, 3]
     #         ]
     #
-    #   horizontal(true)
-    #     #=> [
-    #          [[0, 0], [1, 0], [2, 0]],
-    #          [[0, 1], [1, 1], [2, 1]],
-    #          [[0, 2], [1, 2], [2, 2]]]
-    #         ]
+    #     #=> Note: Values above are for demonstration. Each value will actually be a
+    #               Gameboard::Cell with methods #coord and #val
     #
-    def horizontal(coords = false)
+    def horizontal
       rows = []
       height.times do |y|
-        rows << board.select { |cell| cell.coord.y == y }.map do |cell|
-          coords ? cell.coord.position : cell.value
-        end
+        rows << board.select { |cell| cell.coord.y == y }
       end
       rows
     end
@@ -326,11 +308,9 @@ module Gameboard
       !!nailed
     end
 
-    # Public: Return all valid neighbors of a given coordinate.
+    # Public: Return an array of Gameboard::Cell for valid neighbors of a given coordinate.
     #
-    # point  - The X,Y coordinate neighbors should be based off of.
-    # coords - An optional boolean to return an array of coordinate
-    #          pairs
+    # coord  - an [x, y] coordinate
     #
     #
     # Examples
@@ -343,23 +323,11 @@ module Gameboard
     #                   -------------
     #                   - 0 - 1 - 2 -
     #
-    #   neighbors([1,1])
+    #   neighbors(Coordinate.new(0,0))
     #           #=> [1, 2, 3, "A", "C", "X", "A", 1]
     #
-    #   neighbors([1,1] true)
-    #           #=> [
-    #                [0, 2], [1, 2],
-    #                [2, 2], [0, 1],
-    #                [2, 1], [0, 0],
-    #                [0, 1], [0, 2]
-    #               ]
-    #
-    #
-    def neighbors(point, coords = false)
-      temp = Coordinate.new(point[0], point[1])
-      valid_neighbors(temp).map do |cell|
-        coords ? cell.coord.position : cell.value
-      end
+    def neighbors(coord)
+      find_cell(coord).coord.neighbors.map { |point| find_cell(point) }.compact
     end
 
     # Public: Set random cells to a given value.
@@ -368,19 +336,21 @@ module Gameboard
     #
     def randomize(piece)
       rand(1...board.length).times do
-        board[rand(board.length)].value = piece
+        board[rand(board.length)].val = piece
       end
     end
-    # Public: Set a cells value at a given coordinate
+    # Public: Set a cell's value at a given coordinate. Returns false if no cell found
     #
     # coord - A coordinate pair in the form X, Y
+    #
     def set_cell(coord, value)
       cell = find_cell(coord)
-      raise "Cell Not Found" unless !!cell
-      cell.value = value
+      return false unless cell
+      cell.val = value if cell
     end
 
-    # Public: Return every column on the gameboard.
+    # Public: Return every column on the gameboard. Run #to_val(:vertical) if you only need the
+    #         values at each index
     #
     # coords: An optional boolean to specify returning an Array of coordinates
     #         instead of values.
@@ -402,43 +372,60 @@ module Gameboard
     #          ["Y", "B", 2],
     #          ["Z", "C", 3]
     #         ]
+    #     #=> Note: Values above are for demonstration. Each value will actually be a
+    #               Gameboard::Cell with methods #coord and #val
     #
-    #   vertical(true)
-    #     #=> [
-    #          [[0, 0], [0, 1], [0, 2]],
-    #          [[1, 0], [1, 1], [1, 2]],
-    #          [[2, 0], [2, 1], [2, 2]]]
-    #         ]
-    #
-    def vertical(coords = false)
+    def vertical
       columns = []
       width.times do |x|
-        columns << board.select { |cell| cell.coord.x == x }.map do |cell|
-          coords ? cell.coord.position : cell.value
-        end
+        columns << board.select { |cell| cell.coord.x == x }
       end
       columns
     end
 
+    # Public: Helper method to return values instead of Cells for a given method.
+    #
+    # method_sym - A symbol of the method you want to run.
+    # args       - optional, pass an argument to the method you are calling
+    #
+    # Example
+    #      -------------
+    #    0 | 1 | 2 | 3 |
+    #      -------------
+    #    1 | A | B | C |
+    #      -------------
+    #    2 | X | Y | Z |
+    #      -------------
+    #      - 0 - 1 - 2 -
+    #
+    #
+    #   to_val(:vertical)
+    #     #=> [
+    #          ["X", "A", 1],
+    #          ["Y", "B", 2],
+    #          ["Z", "C", 3]
+    #         ]
+    def to_val(method_sym, args = (no_args = true; nil))
+      (no_args ? public_send(method_sym) : public_send(method_sym,args)).map do |item|
+        item.is_a?(Array) ? item.collect { |cell| cell.val } : item.val
+      end
+    end
+    
     private
       # Internal: Returns the gameboard array.
       attr_reader :board
       # Internal: Returns the default gameboard cell value
-      attr_reader :cells
+      attr_reader :default_cell
       # Internal: Stores whether the board is nailed down
       attr_reader :nailed
 
       # Internal: return a diagonal array given a starting point and a
       #           slope.
-      def get_diagonal(start, coords, slope = true)
-        oper = (slope == true ? :+ : :-)
+      def get_diagonal(start, slope = 1)
         diagonal = (0...height).map do |i|
-          position = [start[0] + i, start[1].send(oper, i)]
-          if ((0...width).include?(start[0] + i) && (0...height).include?(start[1].send(oper, i)))
-            board.find {|cell| cell.coord.position == position}
-          end
+          delta(start, [i, i * slope])
         end
-        diagonal.compact.map{|cell| coords ? cell.coord.position : cell.value }
+        diagonal.compact
       end
 
       # Internal: Set the current gameboard.
@@ -449,7 +436,7 @@ module Gameboard
       #
       # Examples
       #
-      #   board = Board.new(cells: "O", width: 10, height: 8)
+      #   board = Board.new(default_cell: "O", width: 10, height: 8)
       #   # =>     -----------------------------------------
       #          0 | O | O | O | O | O | O | O | O | O | O |
       #            -----------------------------------------
@@ -495,7 +482,7 @@ module Gameboard
         @width = saved_game[0].length
         saved_game.transpose.each_with_index do |row, x|
           row.each.each_with_index  do |cell, y|
-            @board << Cell.new(coord: Coordinate.new(x,y), value: cell)
+            @board << Cell.new(coord: Coordinate.new(x,y), val: cell)
           end
         end
       end
@@ -505,17 +492,9 @@ module Gameboard
         @board = []
         width.times do |x|
           height.times do |y|
-            @board << Cell.new(coord: Coordinate.new(x,y), value: cells)
+            @board << Cell.new(coord: Coordinate.new(x,y), val: default_cell)
           end
         end
       end
-
-      # Internal: use the Coordinate::neighbors function to collect the
-      #           neighbors of a given Coordinate on the existing gameboard
-      #
-      # point - instance of Coordinate class at a specific x,y point
-      def valid_neighbors(coord)
-        coord.neighbors.collect { |point| find_cell(point) }.compact
-      end
   end
 end

data/lib/gameboard/cell.rb

@@ -3,7 +3,7 @@ module Gameboard
   class Cell
 
     # Public: Returns the value of the Cell instance.
-    attr_accessor :value
+    attr_accessor :val
 
     # Public: Retuns the Coordinate of the Cell instance. Returns type
     #         Gameboard::Coordinate.
@@ -14,9 +14,9 @@ module Gameboard
     # coord - A Coordinate class instance at postition X,Y.
     # value - The cell's value.
     #
-    def initialize(coord: false, value: false)
+    def initialize(coord: false, val: false)
       raise TypeError unless coord.is_a?(Coordinate)
-      @value = value
+      @val = val
       @coord = coord
     end
   end

data/lib/gameboard/coordinate.rb

@@ -1,7 +1,6 @@
 module Gameboard
   class Coordinate
     # Public: Returns the X,Y coordinate of the instance as [X, Y].
-    attr_reader :position
     # Public: Returns the X coordinate of the instance.
     attr_reader :x
     # Public: Returns the Y coordinate of the instance.
@@ -15,7 +14,6 @@ module Gameboard
     def initialize(x,y)
       invalid_type = "Coordinates must be integers!"
       raise invalid_type unless (x.is_a?(Integer) && y.is_a?(Integer))
-      @position = [x,y]
       @x = x
       @y = y
     end
@@ -34,6 +32,10 @@ module Gameboard
     def neighbors
       relative_neighbors.map { |point| delta(point) }
     end
+
+    def position
+      [x, y]
+    end
     private
 
       # Internal: Add an array with :position.

data/lib/gameboard/render.rb

@@ -10,11 +10,11 @@ module Gameboard
     # ClassMethod: calls render methods in order of needed
     #              execution.
     #
-    # gameboard - A 2D array built by Board.horizontal
+    # gameboard - A 2D array built by Board.to_val(:horizontal)
     #
     # Example
     #
-    #    Render::board(Board.new(height:3, width: 3).horizontal)
+    #    Render::board(Board.new(height:3, width: 3).to_val(:horizontal))
     #
     def self.board(gameboard)
       system("tput setab 0;") unless Gem.win_platform?

data/lib/gameboard/version.rb

@@ -1,3 +1,3 @@
 module Gameboard
-  VERSION = "3.5.0"
+  VERSION = "4.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gameboard
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Sampson Crowley
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-06 00:00:00.000000000 Z
+date: 2016-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler