rhex 1.2.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a2e40d08cd8b0af78d794a06edabe792d504d1d
-  data.tar.gz: 5f4c074aa457e00505c5c5bad0a2721d55a27180
+  metadata.gz: 8ddd109e085e6fd0019a06bcddeef878e5132045
+  data.tar.gz: 1693182acc5400722ae6598934f71d7dd85acf89
 SHA512:
-  metadata.gz: a2bf038530231da4e29dc9626062a0d2935b522de5b84bb60aa39aa5faffd0f65888571fd3c125fe20d97e850424e81c503eb25ac98c4b9943e298b43345c82b
-  data.tar.gz: 131308282edb5a1a3bb3b6e408884eb1a18c04e3f8b73b6d952014cf879e526e59b74ccbf2566a3e87bcef493db57cf1936093c48ebc0f4e444a2f79e656692e
+  metadata.gz: 6db25e6a50b842d46d001f3c479c2e800f96dc0d96d66fd68e51297f6d2d8efdc52cc3c1f4abc34dc95ff1c10df3436be662b5e852a997d9c277ba18baf1411c
+  data.tar.gz: 0b40396657b73c09556af4923f6862a2df2b41bbce686c945ae9ab352780d4793c5b0a60a12a1401f457c72420947065b884ed52286bc2289fdf6d73ad2df25d

data/lib/hex/axial_grid.rb

@@ -0,0 +1,109 @@
+require_relative 'axial_hex'
+require_relative 'modules/ascii_to_grid'
+require_relative 'modules/grid_to_pic'
+
+# This class represents a grid of hexagons stored in an axial coordinate system.
+#
+# Please read http://www.redblobgames.com/grids/hexagons/#coordinates to understand what an axial coordinates system is.
+class AxialGrid
+
+  include GridToPic
+  include AsciiToGrid
+
+  # Create an hexagon object
+  # - +hex_ray+ is the size of an hexagon. Please read : http://www.redblobgames.com/grids/hexagons/#basics for information about the size of an hexagon.
+  # - +element_to_color_hash+ : is a hash that relate color (see BaseHex::Axial.new) to a color. This is used to dump your grid to a bitmap field.
+  #
+  # Example
+  #
+  #   @g = Hex::Grid.new(
+  #    element_to_color_hash: {
+  #     m: :brown, g: :green, w: :blue
+  #    }
+  #   )
+  #
+  # Assuming you want all hex with a colorue of m are drawn in brown,g in green, etc ... (see GridToPic for drawin a grid)
+  #
+  # *Returns* : a new Hex::Grid object.
+  def initialize( hex_ray: 16, element_to_color_hash: {} )
+    @hexes={}
+    @element_to_color_hash = element_to_color_hash
+    @hex_ray = hex_ray
+    set_hex_dimensions
+  end
+
+  # Set the hex colorue to color conversion hash
+  #
+  # *Returns* : nothing.
+  def set_element_to_color_hash( element_to_color_hash )
+    @element_to_color_hash = element_to_color_hash
+  end
+
+  # Create an hexagon at a given position (q, r)
+  #
+  # You can set a color for the hexagon and set the hex as a border hex or not
+  #
+  # *Returns* : an Hex::Axial object.
+  def cset( q, r, color: nil, border: false, data: nil )
+    @hexes[ [ q, r ] ] = AxialHex.new( q, r, color: color, border: border, data: data )
+  end
+
+  # Same method, but accept an hexagon instead of (q, r) coords
+  #
+  # *Returns* : the created Hex::Axial object.
+  def hset( hex )
+    @hexes[ [ hex.q, hex.r ] ] = hex
+  end
+
+  # Get the hexagon at a given position (q, r)
+  #
+  # *Returns* : the created Hex::Axial object.
+  def cget( q, r )
+    @hexes[ [ q, r ] ]
+  end
+
+  # Same method, but accept an hexagon instead of (q, r) coords
+  #
+  # *Returns* : the created Hex::Axial object.
+  def hget( hex )
+    @hexes[ [ hex.q, hex.r ] ]
+  end
+
+  # Call the block for each Hex in the grid
+  #
+  # *Returns* : nothing
+  def each
+    @hexes.sort.each{ |h| yield h[1] }
+  end
+
+  # Return all surrounding hexes from grid
+  #
+  # *Returns* : Array of AxialHex
+  def h_surrounding_hexes( h )
+    h.surrounding_hexes.map{ |sh| hget( sh ) }
+  end
+
+  # Get the hexagon at (x,y) coordinate.
+  #
+  # *Returns* : the Hex::Axial object at x, y pos.
+  def hex_at_xy(x, y)
+    q = (x * Math.sqrt(3)/3.0 - y/3.0) / @hex_ray
+    r = y * 2.0/3.0 / @hex_ray
+    hex = AxialHex.new(q, r).round
+    cget( hex.q, hex.r )
+  end
+  #
+  # Give the position of an hexagon object in pixel.
+  #
+  # *Returns* : an array of x, y positions.
+  def to_xy( hex )
+
+    set_hex_dimensions
+
+    tmp_q = hex.q
+    x = ( @hex_ray * Math.sqrt(3) * ( tmp_q + hex.r/2.0 ) )
+    y = ( @hex_ray * 3.0/2.0 * hex.r )
+    [ x, y ]
+  end
+
+end

data/lib/hex/axial_hex.rb

@@ -0,0 +1,122 @@
+# -*- encoding : utf-8 -*-
+
+require_relative 'cube_hex'
+
+# This class represents an hexagon stored in axial coordinate system.
+#
+# Please read http://www.redblobgames.com/grids/hexagons/#coordinates
+# to understand what an axial coordinates system is
+class AxialHex < BaseHex
+
+  attr_reader :q, :r #:nodoc:
+
+  # Directions around hex from top left clockwise
+  DIRECTIONS = [ [0,-1], [1,-1], [1,0], [0,1], [-1,+1], [-1,0] ] #:nodoc:
+
+  # Create an hexagon object
+  # - +q+ and +r+ are the coordinates in the axial coords system
+  # - +color+ : is a colorue anything you want.
+  # - +border+ is a boolean and mean that the hex is at the border of the map.
+  #
+  # *Returns* : a new Hex::Axial object.
+  def initialize( q, r, color: nil, border: false, data: nil )
+    @q = q
+    @r = r
+    super( color, border, data )
+  end
+
+  # Check the equality between two hexagons.
+  def ==(h) #:nodoc:
+    @q==h.q && @r==h.r
+  end
+
+  def !=(h) #:nodoc:
+    @q!=h.q || @r!=h.r
+  end
+
+  # Transform an axial represented hexagon object to a cube represented hexagon object.
+  #
+  # *Returns* : a new Hex::Cube object.
+  def to_cube
+    CubeHex.new(@q, -@q-@r, @r)
+  end
+
+  # From an array of hexagons, get the nearest
+  # - +hex_array+ : and array of Hex::Axial objects
+  #
+  # Example
+  #
+  #   hext_to_test = Hex::Axial.new( 5, 5 )
+  #   nearest_hex = Hex::Axial.new( 5, 6 )
+  #   far_hex = Hex::Axial.new( 20, 20 )
+  #
+  #   nearest_hex.nearset_hex( [ hext_to_test, far_hex ] )  #=> #<Hex::Axial @q=5, @r=6>
+  #
+  # *Returns* : the nearset hex as a Hex::Axial object.
+  def nearest_hex( hex_array )
+    nearest_hex = nil
+    current_distance = nil
+    hex_array.each do |h|
+      if nearest_hex
+        dist = distance( h )
+        if distance( h ) < current_distance
+          nearest_hex = h
+          current_distance = dist
+        end
+      else
+        nearest_hex = h
+        current_distance = distance( h )
+      end
+    end
+    nearest_hex
+  end
+
+  ##
+  # Compute the distance (in hex) between two hexagons
+  # - +h+ : an Hex::Axial object
+  #
+  # Example
+  #
+  #   h1 = Hex::Axial.new( 5, 5 )
+  #   h2 = Hex::Axial.new( 20, 20 )
+  #
+  #   h1.distance( h2 )  #=> 30
+  #
+  #   Hex::Axial.new( 5, 5 ).distance( Hex::Axial.new( 5, 5 ) )  #=> 0
+  #   Hex::Axial.new( 5, 5 ).distance( Hex::Axial.new( 5, 1 ) )  #=> 1
+  #
+  # *Returns* : the distance between the two hexes as an integer.
+  def distance( h )
+    to_cube.distance(h.to_cube)
+  end
+
+  # Get all hexagons surrounding the current hexagon
+  #
+  # *Returns* : an array of Hex::Axial.
+  def surrounding_hexes
+    # puts self.inspect, self.q.inspect, self.r.inspect
+    DIRECTIONS.map{ |e| AxialHex.new( @q+e[0], @r+e[1] ) }
+  end
+
+  # Check if an hexagon is around another hexagon
+  #
+  # *Returns* : true if the hexagon is adjacent to the other, false otherwise. Note, h.hex_surrounding_hex?( h ) == false
+  def hex_surrounding_hex?(hex)
+    distance(hex)==1
+  end
+
+  # Round an hexagon coordinates (useful after pixel to axial coordinate transformation)
+  #
+  # *Returns* : an Hex::Axial with coords rounded.
+  def round
+    to_cube.round.to_axial
+  end
+
+  # Transform an hex to it's q, r coordinates
+  #
+  # *Returns* : an array [ q, r ]
+  def qr
+    [ q, r ]
+  end
+
+end

data/lib/hex/base_hex.rb

@@ -0,0 +1,9 @@
+class BaseHex
+  attr_accessor :color, :border, :data #:nodoc:
+
+  def initialize( color = nil, border = nil, data = nil )
+    @color = color if color
+    @border = @border if border
+    @data = data
+  end
+end

data/lib/hex/cube_hex.rb

@@ -0,0 +1,61 @@
+require_relative 'base_hex'
+
+# This class represents an hexagon stored in a cube coordinate system.
+#
+# Please read http://www.redblobgames.com/grids/hexagons/#coordinates
+# to understand what a cube coordinates system is
+# The cube class is only for computation.
+# It is not intended to be used directly in your program.
+class CubeHex < BaseHex
+
+  attr_reader :x,:y,:z #:nodoc:
+
+  # Create an hexagon object
+  # - +x+, +y+, +z+ are the coordinates in the axial coords system
+  #
+  # *Returns* : a new Hex::Cube object.
+  def initialize( x, y, z, color: nil, border: nil, data: nil )
+    @x = x
+    @y = y
+    @z = z
+
+    super( color, border, data )
+  end
+
+  # Transform a cube represented hexagon to an Hexagon::Axial represented hexagon
+  #
+  # *Returns* : a new Hex::Axial object.
+  def to_axial
+    AxialHex.new(@x, @z, color: @color, border: @border, data: @data)
+  end
+
+  # Round the float coordinates to integer coordinates.
+  #
+  # *Returns* : a new Hex::Cube object.
+  def round
+    rx=@x.round(0)
+    ry=@y.round(0)
+    rz=@z.round(0)
+
+    x_diff=(rx-@x).abs
+    y_diff=(ry-@y).abs
+    z_diff=(rz-@z).abs
+
+    if x_diff > y_diff and x_diff > z_diff
+      rx = -ry-rz
+    elsif y_diff > z_diff
+      ry = -rx-rz
+    else
+      rz = -rx-ry
+    end
+    CubeHex.new(rx, ry, rz, color: @color, border: @border, data: @data)
+  end
+
+  # Compute the distance between two hexagons (in hexagons)
+  #
+  # *Returns* : an integer : the distance between hex in hexagons.
+  def distance(h)
+    [(@x - h.x).abs, (@y - h.y).abs, (@z - h.z).abs].max
+  end
+
+end

data/lib/hex/{ascii_to_grid.rb → modules/ascii_to_grid.rb}

@@ -14,7 +14,7 @@ module AsciiToGrid
         elements.each do |element|
           border = true if ( r == 0 || q == 0 )
           shifted_q = q - ( r/2 )
-          cset( shifted_q, r, val: element, border: border )
+          cset( shifted_q, r, color: element, border: border )
           q += 1
         end
         r += 1
@@ -24,11 +24,12 @@ module AsciiToGrid
       0.upto( max_r - 1 ).each do |row|
         maxq = @hexes.map{ |key, e| e.q if e.r == row }.compact.max
         hex = cget( maxq, row )
-        hex.border! if hex
+        hex.border = true if hex
       end
 
-      @hexes.each{ |key, e| e.border! if e.r == ( max_r - 1 ) }
+      @hexes.each{ |key, e| e.border = true if e.r == ( max_r - 1 ) }
 
     end
   end
+
 end

data/lib/hex/{grid_to_pic.rb → modules/grid_to_pic.rb}

@@ -12,29 +12,45 @@ end
 module GridToPic
 
   attr_reader :hex_height, :hex_width #:nodoc:
+  attr_reader :quarter_height, :half_width #:nodoc:
 
-  # Draw a picture of the hexagon grid
-  # - +pic_name+ : the name of the picture file (can be *.bmp, *.png, *.jpg)
+  # Draw the hex grid in a Magick::Image object
   # - +exit_on_error+ : by default, if you call this method and rmagic is not installed, the program exit with an error. You can disable it and make the program continue.
   #
-  # *Returns* : true if the file was created successfully, false otherwise.
-  def to_pic( pic_name, exit_on_error = true )
+  # *Returns* : the Magick::Image object
+  def to_rmagick_image( exit_on_error = true )
     unless defined?( Magick::Image ) && defined?( Magick::HatchFill ) && defined?( Magick::Draw )
       puts 'Rmagick is not installed !!! You can\'t dump hex grid to pic'
       exit if exit_on_error
     end
 
-    maxx = @hexes.keys.map{ |k| k[0] }.max * @hex_width
-    maxy = @hexes.keys.map{ |k| k[1] }.max * @hex_height * 3.0/4.0
+    maxx = ( @hexes.keys.map{ |k| k[0] + k[1]/2 }.max ) * @hex_width - ( @hex_width / 2 ) + 1
+    maxy = @hexes.keys.map{ |k| k[1] }.max * ( ( @hex_height * 3.0 )/ 4.0 ).ceil - ( @hex_width / 4 ).ceil - 2
+
+    # maxx = ( ( @hexes.keys.map{ |k| k[0] + k[1]/2 }.max ) + 0.5 ) * @hex_width
+    # maxy = ( ( @hexes.keys.map{ |k| k[1] }.max * 3.0/4.0 ) + 0.5 ) + @hex_heig
 
     canvas = Magick::Image.new( maxx, maxy )
+
     gc = Magick::Draw.new
     gc.stroke_antialias( true )
     gc.stroke( 'black' )
+    gc.stroke_opacity( '60%' )
 
     @hexes.each{ | _, hex| draw_hex( gc, hex ) }
 
     gc.draw(canvas)
+
+    canvas
+  end
+
+  # Draw the hex grid on a Magick::Object and save it to a file
+  # - +pic_name+ : the name of the picture file (can be *.bmp, *.png, *.jpg)
+  # - +exit_on_error+ : by default, if you call this method and rmagic is not installed, the program exit with an error. You can disable it and make the program continue.
+  #
+  # *Returns* : true if the file was created successfully, false otherwise.
+  def to_pic( pic_name, exit_on_error = true )
+    canvas = to_rmagick_image( exit_on_error )
     canvas.write( pic_name )
   end
 
@@ -51,13 +67,16 @@ module GridToPic
   end
 
   def get_color( hex )
-    color = @element_to_color_hash[ hex.val ]
+    color = @element_to_color_hash[ hex.color ]
     color ? color : :white
   end
 
   def draw_hex( gc, hex )
     x, y = to_xy( hex )
 
+    x -= @hex_width
+    y -= @quarter_height * 2
+
     color = get_color( hex )
     gc.fill( color.to_s )
 

data/lib/hex/square_grid.rb

@@ -0,0 +1,27 @@
+require_relative 'axial_grid'
+require_relative 'cube_hex'
+
+class SquareGrid < AxialGrid
+
+  def cset( col, row, color: nil, border: false, data: nil )
+    hset( even_q_to_axial_hex( col, row, color: color, border: border, data: data ) )
+  end
+
+  def cget( col, row )
+    hget( even_q_to_axial_hex( col, row ) )
+  end
+
+  private
+
+  def even_q_to_axial_hex( col, row, color: nil, border: false, data: nil  )
+    # convert odd-r offset to cube
+    x = col - (row - (row&1)) / 2
+    z = row
+    y = -x-z
+
+    tmp_cube = CubeHex.new( x, y, z, color: color, border: border, data: data )
+
+    tmp_cube.to_axial
+  end
+
+end

data/lib/rhex.rb

@@ -1,3 +1,4 @@
-require_relative 'hex/axial'
-require_relative 'hex/cube'
-require_relative 'hex/grid'
+require_relative 'hex/axial_hex'
+require_relative 'hex/cube_hex'
+require_relative 'hex/axial_grid'
+require_relative 'hex/square_grid'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rhex
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Cédric ZUGER
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-04 00:00:00.000000000 Z
+date: 2016-01-05 00:00:00.000000000 Z
 dependencies: []
 description: |2
       A library providing hexagons management and hexagonal grids for ruby.
@@ -19,11 +19,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/hex/ascii_to_grid.rb
-- lib/hex/axial.rb
-- lib/hex/cube.rb
-- lib/hex/grid.rb
-- lib/hex/grid_to_pic.rb
+- lib/hex/axial_grid.rb
+- lib/hex/axial_hex.rb
+- lib/hex/base_hex.rb
+- lib/hex/cube_hex.rb
+- lib/hex/modules/ascii_to_grid.rb
+- lib/hex/modules/grid_to_pic.rb
+- lib/hex/square_grid.rb
 - lib/rhex.rb
 homepage: https://github.com/czuger/rhex
 licenses:
@@ -35,17 +37,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Ruby HEXagonal grid

data/lib/hex/axial.rb

@@ -1,129 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-require_relative 'cube'
-
-# This module contains is the container for all hexagon classes.
-module Hex
-
-  # This class represents an hexagon stored in axial coordinate system.
-  #
-  # Please read http://www.redblobgames.com/grids/hexagons/#coordinates
-  # to understand what an axial coordinates system is
-  class Axial
-
-    attr_reader :q, :r, :val #:nodoc:
-
-    # Directions around hex from top left clockwise
-    DIRECTIONS = [ [0,-1], [1,-1], [1,0], [0,1], [-1,+1], [-1,0] ] #:nodoc:
-
-    # Create an hexagon object
-    # - +q+ and +r+ are the coordinates in the axial coords system
-    # - +val+ : is a value anything you want.
-    # - +border+ is a boolean and mean that the hex is at the border of the map.
-    #
-    # *Returns* : a new Hex::Axial object.
-    def initialize( q, r, val: nil, border: false )
-      @q = q
-      @r = r
-      @val = val.to_sym if val
-      @border = border
-    end
-
-    # Check the equality between two hexagons.
-    def ==(h) #:nodoc:
-      @q==h.q && @r==h.r
-    end
-
-    # Force the border status of the hex.
-    #
-    # *Returns* : true.
-    def border!
-      @border = true
-    end
-
-    # Get the border status of the hex.
-    #
-    # *Returns* : true if the hex is at the border of the grid, false otherwise (only if border have been set. Return false otherwise).
-    def border?
-      !@border.nil?
-    end
-
-    # Transform an axial represented hexagon object to a cube represented hexagon object.
-    #
-    # *Returns* : a new Hex::Cube object.
-    def to_cube
-      Hex::Cube.new(@q,-@q-@r,@r)
-    end
-
-    # From an array of hexagons, get the nearest
-    # - +hex_array+ : and array of Hex::Axial objects
-    #
-    # Example
-    #
-    #   hext_to_test = Hex::Axial.new( 5, 5 )
-    #   nearest_hex = Hex::Axial.new( 5, 6 )
-    #   far_hex = Hex::Axial.new( 20, 20 )
-    #
-    #   nearest_hex.nearset_hex( [ hext_to_test, far_hex ] )  #=> #<Hex::Axial @q=5, @r=6>
-    #
-    # *Returns* : the nearset hex as a Hex::Axial object.
-    def nearest_hex( hex_array )
-      nearest_hex = nil
-      current_distance = nil
-      hex_array.each do |h|
-        unless nearest_hex
-          nearest_hex = h
-          current_distance = distance( h )
-        else
-          nearest_hex = h if distance( h ) < current_distance
-        end
-      end
-      nearest_hex
-    end
-
-    ##
-    # Compute the distance (in hex) between two hexagons
-    # - +h+ : an Hex::Axial object
-    #
-    # Example
-    #
-    #   h1 = Hex::Axial.new( 5, 5 )
-    #   h2 = Hex::Axial.new( 20, 20 )
-    #
-    #   h1.distance( h2 )  #=> 30
-    #
-    #   Hex::Axial.new( 5, 5 ).distance( Hex::Axial.new( 5, 5 ) )  #=> 0
-    #   Hex::Axial.new( 5, 5 ).distance( Hex::Axial.new( 5, 1 ) )  #=> 1
-    #
-    # *Returns* : the distance between the two hexes as an integer.
-    def distance( h )
-      to_cube.distance(h.to_cube)
-    end
-
-    # Get all hexagons surrounding the current hexagon
-    #
-    # *Returns* : an array of Hex::Axial.
-    def get_surrounding_hexs
-      # puts self.inspect, self.q.inspect, self.r.inspect
-      DIRECTIONS.map{ |e| Hex::Axial.new( @q+e[0], @r+e[1] ) }
-    end
-
-    # Check if an hexagon is around another hexagon
-    #
-    # *Returns* : true if the hexagon is adjacent to the other, false otherwise. Note, h.hex_surrounding_hex?( h ) == false
-    def hex_surrounding_hex?(hex)
-      distance(hex)==1
-    end
-
-    # Round an hexagon coordinates (useful after pixel to axial coordinate transformation)
-    #
-    # *Returns* : an Hex::Axial with coords rounded.
-    def round
-      to_cube.round.to_axial
-    end
-
-  end
-end
-
-
-

data/lib/hex/cube.rb

@@ -1,60 +0,0 @@
-module Hex
-
-  # This class represents an hexagon stored in a cube coordinate system.
-  #
-  # Please read http://www.redblobgames.com/grids/hexagons/#coordinates
-  # to understand what a cube coordinates system is
-  # The cube class is only for computation.
-  # It is not intended to be used directly in your program.
-  class Cube
-
-    attr_reader :x,:y,:z #:nodoc:
-
-    # Create an hexagon object
-    # - +x+, +y+, +z+ are the coordinates in the axial coords system
-    #
-    # *Returns* : a new Hex::Cube object.
-    def initialize(x,y,z)
-      @x = x
-      @y = y
-      @z = z
-    end
-
-    # Transform a cube represented hexagon to an Hexagon::Axial represented hexagon
-    #
-    # *Returns* : a new Hex::Axial object.
-    def to_axial
-      Hex::Axial.new(@x,@z)
-    end
-
-    # Round the float coordinates to integer coordinates.
-    #
-    # *Returns* : a new Hex::Cube object.
-    def round
-      rx=@x.round(0)
-      ry=@y.round(0)
-      rz=@z.round(0)
-
-      x_diff=(rx-@x).abs
-      y_diff=(ry-@y).abs
-      z_diff=(rz-@z).abs
-
-      if x_diff > y_diff and x_diff > z_diff
-        rx = -ry-rz
-      elsif y_diff > z_diff
-        ry = -rx-rz
-      else
-        rz = -rx-ry
-      end
-      Hex::Cube.new(rx,ry,rz)
-    end
-
-    # Compute the distance between two hexagons (in hexagons)
-    #
-    # *Returns* : an integer : the distance between hex in hexagons.
-    def distance(h)
-      [(@x - h.x).abs, (@y - h.y).abs, (@z - h.z).abs].max
-    end
-
-  end
-end

data/lib/hex/grid.rb

@@ -1,88 +0,0 @@
-require_relative 'axial'
-require_relative 'grid_to_pic'
-require_relative 'ascii_to_grid'
-
-module Hex
-
-  # This class represents a grid of hexagons stored in an axial coordinate system.
-  #
-  # Please read http://www.redblobgames.com/grids/hexagons/#coordinates to understand what an axial coordinates system is.
-  class Grid
-
-    include GridToPic
-    include AsciiToGrid
-
-    # Create an hexagon object
-    # - +hex_ray+ is the size of an hexagon. Please read : http://www.redblobgames.com/grids/hexagons/#basics for information about the size of an hexagon.
-    # - +element_to_color_hash+ : is a hash that relate val (see Hex::Axial.new) to a color. This is used to dump your grid to a bitmap field.
-    #
-    # Example
-    #
-    #   @g = Hex::Grid.new(
-    #    element_to_color_hash: {
-    #     m: :brown, g: :green, w: :blue
-    #    }
-    #   )
-    #
-    # Assuming you want all hex with a value of m are drawn in brown,g in green, etc ... (see GridToPic for drawin a grid)
-    #
-    # *Returns* : a new Hex::Grid object.
-    def initialize( hex_ray: 16, element_to_color_hash: {} )
-      @hexes={}
-      @element_to_color_hash = element_to_color_hash
-      @hex_ray = hex_ray
-      set_hex_dimensions
-    end
-
-    # Create an hexagon at a given position (q, r)
-    #
-    # You can set a value for the hexagon and set the hex as a border hex or not
-    #
-    # *Returns* : an Hex::Axial object.
-    def cset( q, r, val: nil, border: false )
-      @hexes[ [ q, r ] ] = Hex::Axial.new( q, r, val: val, border: border )
-    end
-
-    # Same method, but accept an hexagon instead of (q, r) coords
-    #
-    # *Returns* : the created Hex::Axial object.
-    def hset( hex, val: nil, border: false )
-      @hexes[ [ hex.q, hex.r ] ] = Hex::Axial.new( hex.q, hex.r, val: val, border: border )
-    end
-
-    # Get the hexagon at a given position (q, r)
-    #
-    # *Returns* : the created Hex::Axial object.
-    def cget( q, r )
-      @hexes[ [ q, r ] ]
-    end
-
-    # Same method, but accept an hexagon instead of (q, r) coords
-    #
-    # *Returns* : the created Hex::Axial object.
-    def hget( hex )
-      @hexes[ [ hex.q, hex.r ] ]
-    end
-
-    # Get the hexagon at (x,y) coordinate.
-    #
-    # *Returns* : the Hex::Axial object at x, y pos.
-    def hex_at_xy(x, y)
-      q = (x * Math.sqrt(3)/3.0 - y/3.0) / @hex_ray
-      r = y * 2.0/3.0 / @hex_ray
-      hex = Hex::Axial.new(q, r).round
-      cget( hex.q, hex.r )
-    end
-
-    # Give the position of an hexagon object in pixel.
-    #
-    # *Returns* : an array of x, y positions.
-    def to_xy( hex )
-      tmp_q = hex.q
-      x = @hex_ray * Math.sqrt(3) * ( tmp_q + hex.r/2.0 )
-      y = @hex_ray * 3.0/2.0 * hex.r
-      [ x, y ]
-    end
-
-  end
-end