RubyGrid 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 63c31ea89ff50e5ed3aea13d735dd7da612ea187
+  data.tar.gz: cd2f68ec4783d291ce4d02594393a6b62afbbe1e
+SHA512:
+  metadata.gz: 9882afb2fc490723dc72b46ddfa2e8aff36bf15c90daf88d8ec62b781262e66e5334e823dcc8a98bb7ce8c8774fe922383412d3b695ff10c7c23d05b41ebb1e7
+  data.tar.gz: fffe1ce1a8f852db1e94ad4ed9b4f33bf79ce04307768ca375fc8b1273445361df136b4bad154e02d3909d9ab139fa5a680300807afeffde8fb464250ca5fe97

data/lib/rubygrid/grid.rb

@@ -0,0 +1,348 @@
+module RubyGrid
+  class Grid
+    # Grid constructor.
+    # +sizex+ and +sizey+::
+    #   These set the desired size of the grid, 4 by default.
+    # +def_value+::
+    #   The default data to store in a cell by default.
+    def initialize(sizex=4, sizey=4, def_value=nil)
+      @grid = []
+      
+      # Default Grid size is 4x4
+      sizex = 4 unless is_number?(sizex)
+      sizey = 4 unless is_number?(sizey)
+
+      @size_x = sizex
+      @size_y = sizey
+      @def_value = def_value
+
+      # Build the grid and insert the default values.
+      @size_x.times do |x|
+        @grid.push([])
+        
+        @size_y.times do |y|
+          @grid[x].push(def_value)
+        end
+      end
+    end
+
+  public
+
+    def sizex; @size_x; end
+    def sizey; @size_y; end
+    def grid; @grid; end
+    
+    # This checks to see if a given x,y pair are within 
+    # the boundaries of the grid.
+    def is_valid?(x, y)
+      unless (is_number?(x) and is_number?(y))
+        return false
+      end
+      return ((x >= 0 and x < @size_x) and (y >= 0 and y < @size_y))
+    end
+
+    # Returns the center coordinates of the grid
+    def center
+      x = (@size_x - 1)/2
+      y = (@size_y - 1)/2
+      return x,y
+    end
+
+    # Get the data in a given x,y cell.
+    # Returns nil if the cell is not valid.
+    def get_cell(x, y)
+      return @grid[x][y] if is_valid?(x,y)
+    end
+
+    # This method will return a set of cell data in a table.
+    # The 'cells' argument should be an array of x,y pairs of
+    # the cells being requested.
+    def get_cells(cells) # :yields: cell_data
+      data = []
+
+      return data unless cells.respond_to?(:collect)
+
+      cells.each do |x,y|
+        if is_valid?(x,y)
+          if block_given?
+            yield @grid[x][y]
+          else
+            data << @grid[x][y]
+          end
+        end
+      end
+      
+      return block_given? ? nil : data
+    end
+
+    # Sets a given x,y cell to the data object
+    def set_cell(x,y, obj)
+      @grid[x][y] = obj if is_valid?(x,y)
+    end
+    
+    # Resets a given x,y cell to the grid default value
+    def reset_cell(x,y)
+      @grid[x][y] = @def_value if is_valid?(x,y)
+    end
+
+    # Resets the entire grid to the default value
+    def reset_all
+      @size_x.times do |x|
+        @size_y.times do |y|
+          @grid[x][y] = @def_value
+        end
+      end
+    end
+
+    # This method is used to populate multiple cells at once.
+    # +data+::
+    #   This argument must be an Array, with each element 
+    #   consisting of three values: x, y, and the data to 
+    #   set the cell to.
+    #
+    # Example:
+    #
+    #   d = [[4, 4, "X"], [4, 5, "O"], [5, 4, "O"], [5, 5, "X"]]
+    #   grid.populate(d)
+    #
+    # If the object to be populated is nil, it is replaced with
+    # the default value.
+    def populate(data)
+      return unless data.respond_to?(:collect)
+
+      data.each do |x, y, obj|
+        if is_valid?(x,y)
+          obj = @def_value if obj.nil?
+          @grid[x][y] = obj
+        end
+      end
+      return
+    end
+
+    # This method returns the entire grid's contents in a 
+    # flat array suitable for feeding to #populate above.
+    # Useful for recreating a grid layout.
+    # If the +no_default+ argument is non-false, then the 
+    # returned data Array only contains elements who's 
+    # cells are not the default value.
+    # Returns +nil+ if a block is given.
+    def get_contents(no_default=false) # :yields: x, y, cell_data
+      data = []
+      cell_obj = nil
+
+      @size_x.times do |x|
+        @size_y.times do |y|
+          cell_obj = @grid[x][y]
+          unless no_default and cell_obj == @def_value
+            if block_given?
+              yield x, y, cell_obj
+            else
+              data.push([x,y,cell_obj])
+            end
+          end
+        end
+      end
+      
+      return block_given? ? nil : data
+
+    end
+
+    # Convienence method to return an x,y vector pair from the
+    # GRID_* vector constants. Or nil if there is no such 
+    # constant.
+    def get_vector(vector)
+      case vector
+        when TOP_LEFT     then return -1, -1
+        when TOP          then return -1,  0
+        when TOP_RIGHT    then return -1,  1
+        when LEFT         then return  0, -1
+        when CENTER       then return  0,  0
+        when RIGHT        then return  0,  1
+        when BOTTOM_LEFT  then return  1, -1
+        when BOTTOM       then return  1,  0
+        when BOTTOM_RIGHT then return  1,  1
+      else
+        return nil, nil
+      end
+    end
+
+    # Get a cell's neighbor in a given vector.
+    def get_neighbor(x,y, vector)
+      vx, vy = get_vector(vector)
+
+      if vx and vy
+        x = x + vx
+        y = y + vy
+        return @grid[x][y] if is_valid?(x,y)
+      end
+    end
+
+    # Will return an Array of 8 elements, with each element
+    # representing one of the 8 neighbors for the given 
+    # x,y cell. Each element of the returned Array will consist
+    # of the x,y cell pair, plus the data stored there, suitable
+    # for use of the populate method. If the neighbor cell is
+    # outside the grid, then [nil, nil, OUTSIDE] is used
+    # for the value.
+    # If the given x,y values are not sane, an empty Array
+    # is returned instead.
+    def get_neighbors(x,y) # :yields: x, y, cell_data
+      data = []
+      
+      return data unless is_valid?(x,y)
+
+      # The vectors used are x,y pairs between -1 and +1
+      # for the given x,y cell.
+      # IE:
+      # (-1, -1) (0, -1) (1, -1)
+      # (-1,  0) (0,  0) (1,  0)
+      # (-1,  1) (0,  1) (1,  1)
+      # Value of 0,0 is ignored, since that is the cell
+      # we are working with! :D
+      for gx in -1..1
+        for gy in -1..1
+          vx = x + gx
+          vy = y + gy
+
+          unless gx == 0 and gy == 0
+            if is_valid?(vx,vy)
+              if block_given?
+                yield vx, vy, @grid[vx][vy]
+              else
+                data.push([vx, vy, @grid[vx][vy]])
+              end
+            else
+              if block_given?
+                yield nil, nil, OUTSIDE
+              else
+                data.push([nil, nil, OUTSIDE])
+              end
+            end
+          end
+        end
+      end 
+
+      return block_given? ? nil : data
+    end
+
+    # This method will change the grid size. If the new size is
+    # smaller than the old size, data in the cells now 'outside'
+    # the grid is lost. If the grid is now larger, new cells are
+    # filled with the default value given when the grid was first
+    # created.
+    def resize(newx, newy)
+      unless is_number?(newx) and is_number?(newy)
+        return false
+      end
+
+      # Save old data
+      c = get_contents
+      
+      # Reset grid.
+      @grid.clear
+
+      # Set the new sizes.
+      @size_x = newx
+      @size_y = newy
+      
+      newx.times do |x|
+        @grid.push([])
+        
+        newy.times do |y|
+          @grid[x].push(@def_value)
+        end
+      end
+      
+      # Insert the old contents
+      populate(c)
+
+      return true
+    end
+
+    # This method returns an Array of all values in a given 
+    # row 'x' value.
+    # If given a block, then the data in each cell in the row
+    # is passed to the block.
+    def get_row(x) # :yields: cell_data
+      row = []
+
+      if is_number?(x) and (x >= 0 and x < @size_x)
+        row = @grid[x]
+      end
+
+      if block_given?
+        row.each do |obj|
+          yield obj
+        end
+      end
+
+      return block_given? ? nil : row
+    end
+
+    # This method returns an Array of all values in a given
+    # column 'y' value.
+    # If given a block, then the data in each cell in the column
+    # is passed to the block.
+    def get_column(y) # :yields: cell_data
+      col = []
+
+      if is_number?(y) and (y >= 0 and y < @size_y)
+        @size_x.times do |x|
+          if block_given?
+            yield @grid[x][y]
+          else
+            col.push(@grid[x][y])
+          end
+        end
+      end
+
+      return block_given? ? nil : col
+    end
+
+    # This method traverses a line of cells, from a given x,y
+    # going in +vector+ direction. The vector arg is one of the 
+    # Grid::* traversal constants. This will return an Array of
+    # the data of the cells along the traversal path or nil if
+    # the original x,y is not valid or if the vector is not one
+    # of the constant values. The first element of the Array 
+    # will be the first cell -after- the x, y cell given as the
+    # argument.
+    # In the returned Array, each element will be in the format
+    # of [x, y, obj], suitable for #populate.
+    # If a block is given, then each x, y, and data is passed to
+    # the block, and nil is returned.
+    def traverse(x, y, vector) # :yields: x, y, cell_data
+      data = []
+
+      if is_valid?(x,y)
+        vx, vy = get_vector(vector)
+
+        return data unless vx and vy
+
+        gx = x + vx
+        gy = y + vy
+
+        while is_valid?(gx, gy)
+          obj = @grid[gx,gy]
+
+          if block_given?
+            yield gx, gy, obj
+          else
+            data.push([gx, gy, obj])
+          end
+
+          gx = gx + vx
+          gy = gy + vy
+        end
+      end
+
+      return block_given? ? nil : data
+    end
+
+  private
+    def is_number?(n)
+      (n.respond_to?(:even?) and not n.nil?)
+    end
+
+  end
+end

data/lib/rubygrid/version.rb

@@ -0,0 +1,4 @@
+module RubyGrid
+  VERSION = '1.0.0'
+  MAJOR, MINOR, TINY = VERSION.split('.')
+end

data/lib/rubygrid.rb

@@ -0,0 +1,44 @@
+require 'rubygrid/version'
+require 'rubygrid/grid'
+
+module RubyGrid
+
+  # Some constant values. These are set as strings instead of
+  # integer values to prevent clashes of data.
+  OUTSIDE   = "OUTSIDE".freeze
+  NOT_VALID = "NOT_VALID".freeze
+  NIL_VALUE = "NIL_VALUE".freeze
+
+  # Traversal Vector Constants
+  TOP_LEFT = 1
+  TOP = 2
+  TOP_RIGHT = 3
+  LEFT = 4
+  CENTER = 5
+  RIGHT = 6
+  BOTTOM_LEFT = 7
+  BOTTOM = 8
+  BOTTOM_RIGHT = 9
+
+  # Wrapper for Grid#new
+  def RubyGrid.create(x, y, value)
+    return Grid.new(x, y, value)
+  end
+
+  # Yields each of the vector constants in turn, from top-left
+  # to bottom-right.
+  def RubyGrid.get_all_vectors # :yields: vector_constant
+    [TOP_LEFT,
+     TOP,
+     TOP_RIGHT,
+     LEFT,
+     CENTER,
+     RIGHT,
+     BOTTOM_LEFT,
+     BOTTOM,
+     BOTTOM_RIGHT
+    ].each do |v|
+      yield v # :yields: vector_constant
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: RubyGrid
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Randy Carnahan
+- yacn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple gem for grids in Ruby
+email: admin@yacn.pw
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rubygrid.rb
+- lib/rubygrid/version.rb
+- lib/rubygrid/grid.rb
+homepage: https://github.com/yacn/Ruby-Grid
+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.0.6
+signing_key: 
+specification_version: 4
+summary: Grid gem for Games or whatever else you can think of
+test_files: []