waxy 0.1.0

data/lib/waxy/geometry/fractional_hex.rb

@@ -0,0 +1,62 @@
+module Waxy 
+  module Geometry
+
+    class FractionalHex
+
+      attr_accessor :q, :r, :mq, :mr
+
+      # Ints
+      def initialize(_q, _r, _mq, _mr)
+        @q = _q
+        @r = _r
+        @mq = _mq
+        @mr = _mr
+      end
+
+   #  def == (b)
+   #    q == b.q && r == b.r && s == b.s 
+   #  end
+
+   #  def != (b)
+   #    !(self == b)
+   #  end
+
+   #  def + (b)
+   #    Hex.new(q + b.q, r + b.r, s + b.s)
+   #  end
+
+   #  def - (b)
+   #    Hex.new(q - b.q, r - b.r, s - b.s)
+   #  end
+
+   #  # @param a [Hex]
+   #  # @param k [Int]
+   #  def * (k)
+   #    Hex.new(q * k, r * k, s * k)
+   #  end 
+
+   #  def hex_length(hex)
+   #    ((hex.q.abs + hex.r.abs + hex.s.abs) / 2).to_i
+   #  end
+
+   #  def distance(b)
+   #    hex_length(self - b)
+   #  end
+
+   #  def hex_direction(i)
+   #    raise if !(0..5).include?(i)
+   #    HEX_DIRECTIONS[i]
+   #  end
+
+   #  # (0..5, requires modulo prior)
+   #  def hex_neighbor(i)
+   #    self + hex_direction(i)
+   #  end
+
+   #  def polygon_corners(layout)
+
+   #  end
+
+    end
+  end 
+end 

data/lib/waxy/geometry/hex.rb

@@ -0,0 +1,93 @@
+module Waxy 
+  module Geometry
+    class Hex
+
+      attr_accessor :q, :r, :s
+
+      # Vector of 6 x (0.0 - 1.0)
+      # Used to scale the pie slices
+      #   !! @size is typically set during render through a Waxy::Meta
+ 
+      attr_accessor :size
+
+      # All params are Int
+      def initialize(_q, _r, _s = nil)
+        @q = _q
+        @r = _r 
+        @s = _s 
+      end
+
+      # @return [Array]
+     #   initialized here for foreseable geometry calculations, 
+      #   but in general this should be handled through a Meta
+      def size
+        @size ||= [1.0, 1.0, 1.0, 1.0, 1.0, 1.0] 
+        @size 
+      end
+        
+      def == (b)
+        q == b.q && r == b.r && s == b.s 
+      end
+
+      def != (b)
+        !(self == b)
+      end
+
+      def + (b)
+        Hex.new(q + b.q, r + b.r, ( s ? s + b.s : nil))
+      end
+
+      def - (b)
+        Hex.new(q - b.q, r - b.r,  (s ? s - b.s : nil))
+      end
+
+      # @param a [Hex]
+      # @param k [Int]
+      def * (k)
+        Hex.new(q * k, r * k, (s ? s * k : nil))
+      end 
+
+      def hex_length(hex)
+        ((hex.q.abs + hex.r.abs + hex.s.abs) / 2).to_i
+      end
+
+      def distance(b)
+        hex_length(self - b)
+      end
+
+      def hex_direction(i)
+        raise if !(0..5).include?(i)
+        HEX_DIRECTIONS_FLAT[i]
+      end
+
+      # (0..5, requires modulo prior)
+      def hex_neighbor(i)
+        self + hex_direction(i)
+      end
+    end
+
+    #TODO(mjy) fix 
+    def self.point(center, size, i)
+      angle_deg = 60.0 * i
+      angle_rad = Math::PI / 180 * angle_deg
+      Waxy::Geometry::Point.new(
+        ((center.x + size) * Math.cos(angle_rad)), 
+        ((center.y + size ) * Math.sin(angle_rad))
+      )
+    end
+
+    def self.hexagon(center, size)
+      Hexagon.new(   
+                  outer_coords: (1..6).collect{|i| point(center, size, i)} 
+                 ) 
+    end
+
+    def self.triangle(center, size, i)
+      points = [[0,0]]
+      points.push point(center, size, i)
+      points.push point(center, size, (i + 1 == 7 ? 1 : i + 1)) 
+      points
+    end
+
+  end 
+end 

data/lib/waxy/geometry/layout.rb

@@ -0,0 +1,130 @@
+module Waxy 
+  module Geometry
+
+    class Layout
+
+      # Waxy::Geometry::Orientation
+      attr_accessor :orientation
+
+      # Waxy::Geometry::Point
+      attr_accessor :size
+
+      # Waxy::Geometry::Point
+      attr_accessor :origin
+
+      # pixels between hexes
+      # !! Padding is applied at render time, not geometry compute time, i.e. using this will currently 
+      # !! break things like pixel_to_hex
+      attr_accessor :padding
+
+      attr_reader :pad_h_offset, :pad_w_offset
+
+      def initialize(_orientation, _size, _origin, _padding = 0.0) 
+        @orientation = _orientation
+        @size = _size
+        @origin = _origin 
+        @padding = _padding
+        reset_padding
+      end
+
+      def hex_to_pixel(hex)
+        m = orientation
+        x = (m.f0 * hex.q + m.f1 * hex.r) * size.x
+        y = (m.f2 * hex.q + m.f3 * hex.r) * size.y
+
+        Waxy::Geometry::Point.new(x + origin.x,  y + origin.y)
+      end
+
+      def pixel_to_hex(p)
+        m = orientation
+        pt = Waxy::Geometry::Point.new((p.x - origin.x) / size.x,
+                                       (p.y - origin.y) / size.y)
+        q = m.b0 * pt.x + m.b1 * pt.y
+        r = m.b2 * pt.x + m.b3 * pt.y
+
+        Waxy::Geometry::FractionalHex.new(q, r, q * -1.0,  r * -1.0)
+      end
+
+      # @param corner [Integer]
+      def hex_corner_offset(corner, s = nil)
+        s ||= size
+        angle = hex_corner_angle(corner)
+        Waxy::Geometry::Point.new(s.x * Math.cos(angle), s.y * Math.sin(angle))
+      end
+
+      # @param corner [Integer]
+      def hex_corner_angle(corner)
+        2.0 * Math::PI * (orientation.start_angle + corner) / 6
+      end
+
+      # @params h [Waxy::Geometry::Hex]
+      def polygon_corners(h)
+        corners = []
+        center = hex_to_pixel(h)
+        (0..5).each do |i|
+          offset = hex_corner_offset(i) 
+
+          corners.push Waxy::Geometry::Point.new(
+            center.x + offset.x,
+            center.y + offset.y)
+        end
+        corners
+      end
+
+      # Departing from Redblob here
+
+      def point(hex, i, scale = 1.0 )
+        center = hex_to_pixel(hex)
+
+        resized = size.dup
+        resized.x = resized.x * scale
+        resized.y = resized.y * scale 
+
+        offset = hex_corner_offset(i, resized)
+
+        Waxy::Geometry::Point.new( center.x + offset.x, center.y + offset.y  ) 
+      end
+
+      def triangle(hex, i)
+        scale = hex.size[i]
+
+        points = [ hex_to_pixel(hex) ] 
+        points.push point(hex, i, scale)
+        points.push point(hex, (i + 1 == 6 ? 0 : i + 1), scale) 
+        points
+      end
+
+      def triangles(hex)
+        (0..5).each_with_index.collect{|t,i| triangle(hex, i) }
+      end
+
+      #
+      #    Padding methods are not part of Amit's original code. They are not integrated into geometry compute.
+      #
+      
+      def reset_padding
+        reset_h_padding
+        reset_w_padding
+      end
+
+      def reset_h_padding
+        @pad_h_offset = 0.0
+      end
+
+      def reset_w_padding
+        @pad_w_offset = 0.0
+      end
+
+      def increase_h_padding
+        @pad_h_offset += padding
+      end
+
+      def increase_w_padding
+        @pad_w_offset += padding
+      end
+
+    end
+
+  end
+end
+

data/lib/waxy/geometry/orientation.rb

@@ -0,0 +1,50 @@
+module Waxy 
+  module Geometry
+
+    class Orientation
+      attr_accessor :f0, :f1, :f2, :f3,
+        :b0, :b1, :b2, :b3,
+        :start_angle
+
+      def initialize(_f0, _f1, _f2, _f3, _b0, _b1, _b2, _b3, _start_angle)
+        @f0 = _f0
+        @f1 = _f1
+        @f2 = _f2
+        @f3 = _f3
+        @b0 = _b0
+        @b1 = _b1
+        @b2 = _b2
+        @b3 = _b3
+        @start_angle = _start_angle
+      end
+
+      LAYOUT_POINTY = Orientation.new( 
+        Math.sqrt(3.0), 
+        Math.sqrt(3.0) / 2.0,
+        0.0,
+        3.0 / 2.0,
+        Math.sqrt(3.0) / 3.0,
+        -1.0 / 3.0,
+        0.0,
+        2.0 / 3.0,
+        0.5
+      )
+
+      LAYOUT_FLAT = Orientation.new( 
+        3.0 / 2.0,
+        0.0,
+        Math.sqrt(3.0) / 2.0,
+        Math.sqrt(3.0),
+        2.0 / 3.0,
+        0.0,
+        -1.0 / 3.0,
+        Math.sqrt(3.0) / 3.0,
+        0.0
+      ) 
+
+
+    end
+
+  end
+end
+

data/lib/waxy/geometry/point.rb

@@ -0,0 +1,30 @@
+module Waxy 
+  module Geometry
+    
+    class Point
+      attr_accessor :x, :y
+
+      def initialize(_x, _y)
+        @x = _x
+        @y = _y
+      end
+
+      def hex_to_pixel(layout, h)
+        m = layout.orientation
+        x = (m.f0 * h.q + m.f1 * h.r) * layout.size.x
+        y = (m.f2 * h.q + m.f3 * h.r) * layout.size.y
+        return Point.new(x + layout.origin.x, y + layout.origin.y)
+      end
+
+      def hex_corner_offset(layout, corner)
+        size = Point.new(layout.size)
+        angle = 2.0 * M_PI * (layout.orientation.start_angle + corner ) / 6
+        Point.new(size.x * cos(angle), size.y * sin(angle)) 
+      end
+
+
+
+    end
+
+  end
+end

data/lib/waxy/meta.rb

@@ -0,0 +1,71 @@
+module Waxy
+
+  # Instances of Meta contain attributes
+  # that describe the visual appearance of a single hexagon.
+  class Meta
+
+    ## -- Attributes for solid hex layouts
+
+    # Hex border SVG stroke
+    attr_accessor :stroke
+
+    # Hex fill
+    # not applicable to all templates 
+    attr_accessor :fill
+   
+    # a URL for the whole hexagon
+    # not applicable to all templates
+    attr_accessor :link
+
+    # title value for hex <a>
+    attr_accessor :link_title 
+
+    ## -- Attributes for "pie" layouts
+     
+    # Array of 6 * (0.0..1.0)
+    #  scales "pie" slices
+    attr_accessor :size
+
+    # An Array (0..5) of links, one for each slice of 'Pie' 
+    attr_accessor :pie_links
+
+    # An Array (0..5) of SVG color values  
+    attr_accessor :colors
+
+    # @return [Array]
+    #   6 strings with SVG color= values
+    def colors
+      @colors.nil? ? Waxy::COLORS.values : @colors
+    end
+
+    def pie_links
+      @pie_links.nil? ? [] : @pie_links 
+    end
+
+    # Describes how "full" a pie hexagon is 
+    def sum_size
+      size.sum
+    end
+   
+    #  Helper methods
+     
+    def hex_link_start
+      return nil unless link
+      [
+        '<a href="' + link + '"',
+        'class="waxy__link"',
+        '>'
+      ].compact.join(' ')
+    end
+
+    def hex_link_title
+      return nil unless link_title 
+      "<title>#{link_title}</title>"
+    end
+
+    def hex_link_end
+      '</a>' if link
+    end
+
+  end
+end

data/lib/waxy/render.rb

@@ -0,0 +1,20 @@
+require 'erb'
+require 'tilt'
+
+require_relative 'render/svg'
+require_relative 'render/canvas'
+
+module Waxy
+
+  module Render
+    COLORS = {
+      1 => 'yellow',
+      2 => 'orange',
+      3 => 'red',
+      4 => 'purple',
+      5 => 'blue',
+      6 => 'green'
+    }
+
+  end
+end