gameboard 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bcfddb51f3639e1373ef17d1d4a881dd9dded868
-  data.tar.gz: 69e07edf0d00b39334265b1d5f8abb4ada46b31d
+  metadata.gz: 1c8e6df5d8715f5d0898234d23edc0417729094d
+  data.tar.gz: e89ce29f16f49a4f55b8ef2e57d56eaa44403705
 SHA512:
-  metadata.gz: e2d86c808b6f71b017a4f721d22cfc2bced6c3c1ab2cea591ef69e32c46a43cacce0d6e58188ba357a6b0250a2a7c6eb7836290d12960395c7367ee6c6fe94db
-  data.tar.gz: 58e1c58dafb7e3c0a8213f7d5ab8cb2e9b904c8515573a855d7de6093a7a107ffa32c959ccbed8140c8dc56fae86e917f8c1f32cccf178e43dc7435262c29d38
+  metadata.gz: 36c8119c7f31471c50c2b4a5e982d2cf03876b0304b4487165ee56af1bd437754eb49b2a5ef2783b07a2fa121124c1c178477d9038ab65597ff1791b027a7b1f
+  data.tar.gz: 12b1f18b37a0af525fbe5599b25428d67b98f21df07f7da6234c4f8a24aa5399e6d067ec457383c3253ac0579d94e1204376b880e4049f1bb42953cc89d42432

data/bin/preview

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'gameboard'
+
+class ShowOff
+  include Gameboard
+  def initialize
+    # set = [
+    #        [1,2,3],
+    #        ["A", "B", "C"],
+    #        ["X", "Y", "Z"]
+    #       ]
+    board = Board.new(height: 8, width: 10, cells: "O")
+    # board = Board.new(preset: set)
+    Render.board(board.horizontal)
+  end
+end
+
+ShowOff.new

data/lib/gameboard.rb

@@ -1,7 +1,42 @@
 require "gameboard/version"
+require "gameboard/render"
 require "gameboard/board"
 
-module Gameboard
-  # Your code goes here...
 
+module Gameboard
+  # Public: a purely coordinate based gameboard
+  # run the preview executable to preview the Render class
+  #
+  # Class List:
+  #
+  # Board
+  # Cell
+  # Coordinate
+  # Render
+  #
+  # Examples
+  #
+  #   include Gameboard
+  #   board = Board.new(width:10, height: 8, cells: "O")
+  #   Render.board(board.horizontal)
+  #   # =>     -----------------------------------------
+  #          0 | O | O | O | O | O | O | O | O | O | O |
+  #            -----------------------------------------
+  #          1 | O | O | O | O | O | O | O | O | O | O |
+  #            -----------------------------------------
+  #          2 | O | O | O | O | O | O | O | O | O | O |
+  #            -----------------------------------------
+  #          3 | O | O | O | O | O | O | O | O | O | O |
+  #            -----------------------------------------
+  #          4 | O | O | O | O | O | O | O | O | O | O |
+  #            -----------------------------------------
+  #          5 | O | O | O | O | O | O | O | O | O | O |
+  #            -----------------------------------------
+  #          6 | O | O | O | O | O | O | O | O | O | O |
+  #            -----------------------------------------
+  #          7 | O | O | O | O | O | O | O | O | O | O |
+  #            -----------------------------------------
+  #            - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 -
+  #
+  # Render.board assumes that data is being passed row by row
 end

data/lib/gameboard/board.rb

@@ -1,10 +1,70 @@
 require_relative './cell'
 
 module Gameboard
+  # The Main Board Model
+
   class Board
-    attr_reader :height, :width, :board
+    # Public: Returns the height of the gameboard.
+    attr_reader :height
+
+    # Public: Returns the width of the gameboard.
+    attr_reader :width
+
     include Enumerable
 
+    # 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.
+    #
+    # Examples
+    #
+    #   board = Board.new(cells: "O", width: 10, height: 8)
+    #   # =>     -----------------------------------------
+    #          0 | O | O | O | O | O | O | O | O | O | O |
+    #            -----------------------------------------
+    #          1 | O | O | O | O | O | O | O | O | O | O |
+    #            -----------------------------------------
+    #          2 | O | O | O | O | O | O | O | O | O | O |
+    #            -----------------------------------------
+    #          3 | O | O | O | O | O | O | O | O | O | O |
+    #            -----------------------------------------
+    #          4 | O | O | O | O | O | O | O | O | O | O |
+    #            -----------------------------------------
+    #          5 | O | O | O | O | O | O | O | O | O | O |
+    #            -----------------------------------------
+    #          6 | O | O | O | O | O | O | O | O | O | O |
+    #            -----------------------------------------
+    #          7 | O | O | O | O | O | O | O | O | O | O |
+    #            -----------------------------------------
+    #            - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 -
+    #
+    #
+    #   example_arr = [
+    #                  ["1", "2", "3"], #=> coordinates [[0,2], [1,2], [2,2]]
+    #                  ["A", "B", "C"], #=> coordinates [[0,1], [1,1], [2,1]]
+    #                  ["X", "Y", "Z"]  #=> coordinates [[0,0], [1,0], [2,0]]
+    #                 ]
+    #
+    #   board = Board.new(preset: example_array)
+    #           #=>     -------------
+    #                 0 | 1 | 2 | 3 |
+    #                   -------------
+    #                 1 | A | B | C |
+    #                   -------------
+    #                 2 | X | Y | Z |
+    #                   -------------
+    #                   - 0 - 1 - 2 -
+    #
+    #
     def initialize(height:false, width: false, cells: false, preset: false)
       raise ArgumentError unless ((height.is_a?(Integer) && width.is_a?(Integer)) || !!preset)
       @height = height
@@ -13,29 +73,125 @@ module Gameboard
       preset ? load_game(preset) : new_board
     end
 
+    # Public: An enumerator that passes the individual cells.
+    #
+    # block - Individual cells have a :coord and a :value method where :coord
+    #         is a member of the Coordinate class
+    #
+    # Example
+    #
+    #   board.each { |cell| p cell }
+    #     #=> #<Gameboard::Cell:0x005637e5004790
+    #            @value = "O",
+    #            @coord = #<Gameboard::Coordinate:0x005637e5004a88
+    #                        @position = [0, 0], @x = 0, @y = 0>>
+    #
+    #     #=> #<Gameboard::Cell...
+    #
     def each(&block)
       return enum_for(__method__) if block.nil?
       board.each(&block)
       board
     end
 
+    # Public: An enumerator that yields each cells value.
+    # Example
+    #
+    #   board.each_value { |cell| p cell }
+    #     #=> "O"
+    #     #=> "X"
+    #     #=> "X"...
+    #
     def each_value(&block)
       return enum_for(__method__) if block.nil?
       each{|cell| yield(cell.value)}
     end
 
+    # Public: An enumerator that yields each cells coordinates.
+    # Example
+    #
+    #   board.each { |cell| p cell }
+    #     #=> [0, 0]
+    #     #=> [1, 0]
+    #     #=> [2, 0]
+    #     #=> [0, 1]
+    #     #=> [1, 1]...
+    #
     def each_coordinate(&block)
       return enum_for(__method__) if block.nil?
       each { |cell| yield(cell.coord.position) }
     end
 
-    def delta(point, slope, coord = false)
+    # Public: Return the value of the next available point given a coordinate
+    #         and a slope.
+    #
+    # point  - The starting coordinate pair.
+    # 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
+    #          instead of a value.
+    #
+    # Example
+    #   given_board =   -------------
+    #                 0 | 1 | 2 | 3 |
+    #                   -------------
+    #                 1 | A | B | C |
+    #                   -------------
+    #                 2 | X | Y | Z |
+    #                   -------------
+    #                   - 0 - 1 - 2 -
+    #
+    #   delta([1,1], [-1, 1])
+    #     #=> 1 ([0,2] if coord argument given)
+    #
+    #   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
-      coord ? piece.coord.position : piece.value
+      coords ? piece.coord.position : piece.value
     end
 
+    # Public: Return every diagonal on the gameboard. It does not require a
+    #         square board to function.
+    #
+    # coords: An optional boolean to specify returning an Array of coordinates
+    #         instead of values.
+    #
+    # Example
+    #      -------------
+    #    0 | 1 | 2 | 3 |
+    #      -------------
+    #    1 | A | B | C |
+    #      -------------
+    #    2 | X | Y | Z |
+    #      -------------
+    #      - 0 - 1 - 2 -
+    #
+    #
+    #   diagonal
+    #     #=> [
+    #          ["X", "B", 3], [1, "B", "Z"],
+    #          ["A", 2], ["A", "Y"], [1], ["X"],
+    #          ["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]]
+    #         ]
+    #
     def diagonal(coords = false)
       diagonals = []
 
@@ -51,52 +207,167 @@ module Gameboard
       diagonals
     end
 
+    # Public: Find a cell at given coordinate.
+    #
+    # coord - An X,Y coordinate passed as an Array.
+    #
+    # Example
+    #      -------------
+    #    0 | 1 | 2 | 3 |
+    #      -------------
+    #    1 | A | B | C |
+    #      -------------
+    #    2 | X | Y | Z |
+    #      -------------
+    #      - 0 - 1 - 2 -
+    #
+    #
+    #   find_cell([1,0])
+    #     #=> Y
+    #
+    #   find_cell([2,2])
+    #     #=> 3
+    #
+    # find_cell([0,1])
+    #     #=> A
+    #
     def find_cell(coord)
       board.find {|cell| cell.coord.position == coord}
     end
 
+    # Public: Check if the gameboard is full relative to the default cell.
+    #
+    #
+    #
+    # Example
+    #
+    #    Board.new(height: 3, width: 3)
+    #      -------------
+    #    0 | 1 | 2 | 3 |
+    #      -------------
+    #    1 | A | B | C |
+    #      -------------
+    #    2 | X | Y | Z |
+    #      -------------
+    #      - 0 - 1 - 2 -
+    #
+    #   full?
+    #     #=> true
+    #
+    #   Board.new(height: 3, width: 3, cells: "Y")
+    #
+    #   full?
+    #     #=> false (because our default piece is now "Y")
+    #
     def full?
       board.none? { |cell| cell.value == cells  }
     end
 
+    # Public: Return every row on the gameboard.
+    #
+    # coords: An optional boolean to specify returning an Array of coordinates
+    #         instead of values.
+    #
+    # Example
+    #      -------------
+    #    0 | 1 | 2 | 3 |
+    #      -------------
+    #    1 | A | B | C |
+    #      -------------
+    #    2 | X | Y | Z |
+    #      -------------
+    #      - 0 - 1 - 2 -
+    #
+    #
+    #   horizontal
+    #     #=> [
+    #          ["X", "Y", "Z"],
+    #          ["A", "B", "C"],
+    #          [1, 2, 3]
+    #         ]
+    #
+    #   horizontal(true)
+    #     #=> [
+    #          [[0, 0], [1, 0], [2, 0]],
+    #          [[0, 1], [1, 1], [2, 1]],
+    #          [[0, 2], [1, 2], [2, 2]]]
+    #         ]
+    #
     def horizontal(coords = false)
-      columns = []
+      rows = []
       height.times do |y|
-        columns << board.select { |cell| cell.coord.y == y }.map do |cell|
+        rows << board.select { |cell| cell.coord.y == y }.map do |cell|
           coords ? cell.coord.position : cell.value
         end
       end
-      columns
+      rows
     end
 
-    def load_game(saved_game)
-      @board = []
-      saved_game.reverse!
-      @height = saved_game.length
-      @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(Coordinate.new(x,y), value: cell)
-        end
-      end
-    end
-
-    def neighbors(coord, points = false)
-      temp = Coordinate.new(coord[0], coord[1])
+    # Public: Return all 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
+    #
+    #
+    # Examples
+    #                   -------------
+    #                 0 | 1 | 2 | 3 |
+    #                   -------------
+    #                 1 | A | B | C |
+    #                   -------------
+    #                 2 | X | Y | Z |
+    #                   -------------
+    #                   - 0 - 1 - 2 -
+    #
+    #   neighbors([1,1])
+    #           #=> [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|
-        points ? cell.coord.position : cell.value
-      end
-    end
-
-    def new_board
-      @board = []
-      width.times do |x|
-        height.times do |y|
-          @board << Cell.new(Coordinate.new(x,y), value: cells)
-        end
+        coords ? cell.coord.position : cell.value
       end
     end
 
+    # Public: Return every column on the gameboard.
+    #
+    # coords: An optional boolean to specify returning an Array of coordinates
+    #         instead of values.
+    #
+    # Example
+    #      -------------
+    #    0 | 1 | 2 | 3 |
+    #      -------------
+    #    1 | A | B | C |
+    #      -------------
+    #    2 | X | Y | Z |
+    #      -------------
+    #      - 0 - 1 - 2 -
+    #
+    #
+    #   vertical
+    #     #=> [
+    #          ["X", "A", 1],
+    #          ["Y", "B", 2],
+    #          ["Z", "C", 3]
+    #         ]
+    #
+    #   vertical(true)
+    #     #=> [
+    #          [[0, 0], [0, 1], [0, 2]],
+    #          [[1, 0], [1, 1], [1, 2]],
+    #          [[2, 0], [2, 1], [2, 2]]]
+    #         ]
+    #
     def vertical(coords = false)
       columns = []
       width.times do |x|
@@ -108,6 +379,9 @@ module Gameboard
     end
 
     private
+      # Internal: Returns the gameboard array.
+      attr_reader :board
+      # Internal: Returns the default gameboard cell value
       attr_reader :cells
 
       def get_diagonal(start, coords, slope = true)
@@ -121,6 +395,79 @@ module Gameboard
         diagonal.compact.map{|cell| coords ? cell.coord.position : cell.value }
       end
 
+      # Internal: Set the current gameboard.
+      #
+      # saved_game - An 2D Array. Saved games should be created in rows from
+      #              the top down.
+      #
+      #
+      # Examples
+      #
+      #   board = Board.new(cells: "O", width: 10, height: 8)
+      #   # =>     -----------------------------------------
+      #          0 | O | O | O | O | O | O | O | O | O | O |
+      #            -----------------------------------------
+      #          1 | O | O | O | O | O | O | O | O | O | O |
+      #            -----------------------------------------
+      #          2 | O | O | O | O | O | O | O | O | O | O |
+      #            -----------------------------------------
+      #          3 | O | O | O | O | O | O | O | O | O | O |
+      #            -----------------------------------------
+      #          4 | O | O | O | O | O | O | O | O | O | O |
+      #            -----------------------------------------
+      #          5 | O | O | O | O | O | O | O | O | O | O |
+      #            -----------------------------------------
+      #          6 | O | O | O | O | O | O | O | O | O | O |
+      #            -----------------------------------------
+      #          7 | O | O | O | O | O | O | O | O | O | O |
+      #            -----------------------------------------
+      #            - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 -
+      #
+      #
+      #   example_arr = [
+      #                  ["1", "2", "3"], #=> coordinates [[0,2], [1,2], [2,2]]
+      #                  ["A", "B", "C"], #=> coordinates [[0,1], [1,1], [2,1]]
+      #                  ["X", "Y", "Z"]  #=> coordinates [[0,0], [1,0], [2,0]]
+      #                 ]
+      #
+      #   load_game(example_arr)
+      #           #=>     -------------
+      #                 0 | 1 | 2 | 3 |
+      #                   -------------
+      #                 1 | A | B | C |
+      #                   -------------
+      #                 2 | X | Y | Z |
+      #                   -------------
+      #                   - 0 - 1 - 2 -
+      #           #=> @height and @width will both now equal 3
+      #
+      #
+      def load_game(saved_game)
+        @board = []
+        saved_game.reverse!
+        @height = saved_game.length
+        @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)
+          end
+        end
+      end
+
+      # Internal: Set up a brand new blank board
+      def new_board
+        @board = []
+        width.times do |x|
+          height.times do |y|
+            @board << Cell.new(coord: Coordinate.new(x,y), value: cells)
+          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