grid_generator 0.1.0

data/lib/grid_generator/cubic/top_grid.rb

@@ -0,0 +1,27 @@
+require './lib/grid_generator/cubic/grid'
+
+module GridGenerator
+  module Cubic
+    class TopGrid < Cubic::Grid
+      def width_unit
+        @width_unit ||= Matrix.column_vector([units, units/2])
+      end
+  
+      def height_unit
+        @height_unit ||= Matrix.column_vector([-units, units/2])
+      end
+  
+      def offset_unit
+        @offset_unit ||= Matrix.column_vector([units,0])
+      end
+  
+      def line_offset_amount
+        height
+      end
+  
+      def square_offset_amount
+        height - 1
+      end
+    end
+  end
+end 

data/lib/grid_generator/face_parser.rb

@@ -0,0 +1,43 @@
+module GridGenerator
+  class FaceParser
+    COLOURS = { 
+      'w' => '#ffffff',
+      'y' => '#ffff00',
+      'b' => '#0000ff',
+      'g' => '#00ff00',
+      'r' => '#ff0000',
+      'o' => '#ffb000',
+      'gr' => '#808080',
+      'br' => '#804000',
+      's' => '#8080ff',
+      'l' => '#80ff80',
+      'p' => '#800080', 
+      'pi' => '#ff8080'
+    } 
+  
+    OPACITY = {
+      full: 1,
+      faded: 0.4
+    }
+  
+    def initialize(string)
+      @string = string
+    end
+  
+    attr_reader :string
+  
+    def to_a
+      string.split(/\\n/).map do |line|
+        line.split(',').map(&:strip).map do |col|
+          if col == '-'
+            nil
+          else
+            colour = COLOURS[col.downcase]
+            opacity = OPACITY[(/[[:upper:]]/.match(col) ? :full : :faded)]
+            { colour: colour, opacity: opacity }
+          end
+        end
+      end 
+    end
+  end
+end

data/lib/grid_generator/megaminx/common.rb

@@ -0,0 +1,94 @@
+require 'matrix'
+module GridGenerator
+  module Megaminx
+    module Common
+      ROTATION_STEP = 2 * Math::PI / 5
+
+      ROTATION_MATRIX = Proc.new do |theta|
+        Matrix[
+          [Math.cos(theta), -1*Math.sin(theta)], 
+          [Math.sin(theta), Math.cos(theta)]
+        ]
+      end
+
+      ROTATION_MATRICES = Array.new(5) do |i|
+        ROTATION_MATRIX.call(ROTATION_STEP * i)
+      end
+
+      def rotation_offset_matrix 
+        @rotation_offset_matrix ||= ROTATION_MATRIX.call(rotation_offset)
+      end
+
+      def rotation_point
+        @rotation_point ||= Matrix.column_vector([x+2*units, y+2*units])
+      end
+
+      def rotate(matrix, point)
+        (matrix * (point - rotation_point)) + rotation_point
+      end
+
+      # line
+  
+      def intersection(a,b,c,d)
+        x1 = a[0,0]
+        y1 = a[1,0] 
+        x2 = b[0,0]
+        y2 = b[1,0]
+        x3 = c[0,0]
+        y3 = c[1,0]
+        x4 = d[0,0]
+        y4 = d[1,0] 
+  
+        px_numerator = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4)
+        px_denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4) 
+  
+        py_numerator = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4)
+        py_denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)
+  
+        px = px_numerator / px_denominator
+        py = py_numerator / py_denominator
+  
+        Matrix.column_vector([px, py])
+      end
+
+      # points
+      
+      def top_outer_corner
+        @top_outer_corner ||= rotate(rotation_offset_matrix, Matrix.column_vector([x+2*units,y]))
+      end
+
+      def top_outer_edge
+        point_a, point_b = outer_corners.first(2)
+        @top_outer_edge = (point_a + point_b) / 2 
+      end
+
+      def top_inner_corner
+        intersection(outer_edges[4], outer_edges[1], outer_edges[3], outer_edges[0])
+      end
+
+      def outer_corners
+        @outer_corners ||= ROTATION_MATRICES.map do |matrix|
+          rotate(matrix, top_outer_corner)
+        end
+      end
+
+      def outer_edges
+        @outer_edges ||= ROTATION_MATRICES.map do |matrix|
+          rotate(matrix, top_outer_edge)
+        end
+      end
+
+      def inner_corners
+        @inner_corners ||= ROTATION_MATRICES.map do |matrix|
+          rotate(matrix, top_inner_corner)
+        end
+      end
+
+      def outer_edges_ordered_by_evens_then_odds
+        evens = outer_edges.select.with_index { |_,i| i % 2 == 0 } 
+        odds = outer_edges.select.with_index { |_,i| i % 2 == 1 } 
+        evens + odds
+      end
+    end
+  end
+end

data/lib/grid_generator/megaminx/element_factory.rb

@@ -0,0 +1,52 @@
+require './lib/grid_generator/base_element'
+require './lib/grid_generator/megaminx/common'
+
+module GridGenerator
+  module Megaminx
+    class ElementFactory
+      include GridGenerator::Megaminx::Common
+
+      CENTER_INDEX = 0
+      EDGE_INDEX = 1
+      CORNER_INDEX = 2
+
+      def initialize(x: , y:, row_index:, element_index:, units:, colour:, opacity:, rotation_offset: 0) 
+        @x, @y = x, y
+        @row_index = row_index
+        @element_index = element_index
+        @units = units
+        @colour = colour
+        @opacity = opacity
+        @rotation_offset = rotation_offset
+      end
+
+      attr_reader :x, :y, :row_index, :element_index, :units, :colour, :opacity, :rotation_offset
+
+      def points
+        case row_index
+        when CENTER_INDEX
+          inner_corners  
+        when EDGE_INDEX
+          [
+            outer_edges[element_index], 
+            inner_corners[(element_index+1) % 5], 
+            inner_corners[element_index], 
+          ]
+        when CORNER_INDEX
+          [
+            outer_corners[element_index], 
+            outer_edges[element_index], 
+            inner_corners[element_index], 
+            outer_edges[(element_index-1) % 5], 
+          ]
+        else
+          raise ArgumentError, "unknown row #{row_index}"
+        end
+      end
+
+      def build
+        GridGenerator::BaseElement.new(points: points, colour: colour, opacity: opacity)
+      end
+    end
+  end
+end

data/lib/grid_generator/megaminx/face.rb

@@ -0,0 +1,79 @@
+require './lib/grid_generator/face_parser'
+require './lib/grid_generator/megaminx/common'
+require './lib/grid_generator/megaminx/element_factory'
+
+module GridGenerator
+  module Megaminx
+    class Face
+      include GridGenerator::Megaminx::Common
+  
+      def initialize(x:, y: , units: , elements: , rotation_offset: 0, label: nil)
+        @x, @y = x, y
+        @units = units
+        @elements = FaceParser.new(elements).to_a
+        @rotation_offset = rotation_offset
+        @label = label
+      end
+  
+      attr_reader :x, :y, :units, :elements, :rotation_offset, :label
+
+      # outline
+      
+      def outline_string
+        outer_corners.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
+      end
+  
+      def inner_string
+        inner_corners.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
+      end
+  
+      def inline_string
+        outer_edges_ordered_by_evens_then_odds.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
+      end
+  
+      # elements 
+      
+      def element_shapes
+        elements.each_with_index.map do |row, row_index|
+          row.each_with_index.map do |element, element_index|
+            GridGenerator::Megaminx::ElementFactory.new(
+              x: x,
+              y: y,
+              row_index: row_index,
+              element_index: element_index,
+              units: units,
+              colour: element[:colour],
+              opacity: element[:opacity],
+              rotation_offset: rotation_offset
+            ).build if element
+          end
+        end.flatten.compact
+      end
+
+      # label methods
+  
+      def label_position
+        x = rotation_point[0,0] - units*0.3
+        y = rotation_point[1,0] + units*0.4
+        {
+          x: x.round, 
+          y: y.round 
+        }
+      end
+  
+      def label_size
+        units
+      end
+
+      def as_json
+        {
+          "outline_string" => outline_string,
+          "inline_string" => inline_string,
+          "element_shapes" => element_shapes.as_json,
+          "label_position" => label_position,
+          "label_size" => label_size
+        }
+      end
+    end
+  end
+end

data/lib/grid_generator/pyraminx/grid.rb

@@ -0,0 +1,83 @@
+require './lib/grid_generator/pyraminx/triangle_factory'
+
+module GridGenerator
+  module Pyraminx
+    class Grid 
+      def initialize(x: ,y:, size: ,units: ,elements:)
+        @x, @y = x, y
+        @size = size
+        @units = units
+        @elements = elements
+      end
+    
+      attr_reader :x, :y, :size, :units, :elements
+    
+      def shape_points
+        [
+          [ x+size*units, y ],
+          [ x+2*size*units, y+size*units ],
+          [ x+size*units, y+2*size*units ],
+          [ x, y+size*units ]
+        ]
+      end
+    
+      def shape_points_string
+        shape_points.map { |x,y| [x,y].join(',') }.join(' ')
+      end
+    
+      def vertical_line_points
+        Array.new((2*size)-1) do |i|
+          { 
+            "x1" => x+((i+1)-size).abs*units, 
+            "y1" => y+(i+1)*units,  
+            "x2" => x+((((i+1)-size).abs*-1)+2*size)*units,
+            "y2" => y+(i+1)*units 
+          }
+        end
+      end
+    
+      def diagonal_down_line_points
+        Array.new(size-1) do |i|
+          {
+            "x1" => x+((i-1).abs + 1)*units,
+            "y1" => y+(i+1)*units,
+            "x2" => x+((i-1).abs + 1 + size)*units,
+            "y2" => y+(i+1+size)*units
+          }
+        end
+      end
+    
+      def diagonal_up_line_points
+        Array.new(size-1) do |i|
+          {
+            "x1" => x+(i+1)*units,
+            "y1" => y+(i+1+size)*units,
+            "x2" => x+(i+1+size)*units,
+            "y2" => y+(i+1)*units
+          }
+        end
+      end
+    
+      def element_shapes
+        elements.map do |row|
+          row.map do |element|
+            if element 
+              GridGenerator::Pyraminx::TriangleFactory.new(x: x, y: y, units: units, direction: element[:direction], colour: element[:colour], opacity: element[:opacity]).build
+            else
+              nil
+            end
+          end
+        end.flatten.compact
+      end
+
+      def as_json
+        {
+          "vertical_line_points" => vertical_line_points,
+          "diagonal_down_line_points" => diagonal_down_line_points,
+          "diagonal_up_line_points" => diagonal_up_line_points,
+          "element_shapes" => element_shapes.map(&:as_json)
+        }
+      end
+    end
+  end
+end

data/lib/grid_generator/pyraminx/triangle_factory.rb

@@ -0,0 +1,45 @@
+require './lib/grid_generator/base_element'
+
+module GridGenerator
+  module Pyraminx
+    class TriangleFactory
+      def initialize(x:, y:, units:, direction:, colour:, opacity:)
+        @x, @y = x, y
+        @units = units
+        @direction = direction
+        @colour = colour
+        @opacity = opacity
+      end
+
+      attr_reader :x, :y, :units, :direction, :colour, :opacity
+
+      def up_points
+        [
+          Matrix.column_vector([ x+units, y ]),
+          Matrix.column_vector([ x+2*units, y+units ]),
+          Matrix.column_vector([ x, y+units ])
+        ]
+      end
+
+      def down_points
+        [
+          Matrix.column_vector([ x+units, y+units ]),
+          Matrix.column_vector([ x+2*units, y ]),
+          Matrix.column_vector([ x, y ])
+        ]
+      end
+
+      def points
+        if direction == :up
+          up_points
+        else
+          down_points
+        end
+      end
+      
+      def build
+        GridGenerator::BaseElement.new(points: points, colour: colour, opacity: opacity)
+      end
+    end
+  end
+end

data/lib/grid_generator/skewb/left_element_factory.rb

@@ -0,0 +1,90 @@
+module GridGenerator
+  module Skewb
+    class LeftElementFactory
+      def initialize(grid_x:, grid_y:, row_num:, col_num:, side_size:, units:, colour:, opacity:)
+        @grid_x, @grid_y = grid_x, grid_y
+        @row_num, @col_num = row_num, col_num
+        @side_size, @units = side_size, units
+        @colour, @opacity = colour, opacity
+      end
+
+      attr_reader :grid_x, :grid_y, :row_num, :col_num, :side_size, :units, :colour, :opacity
+
+      def x
+        @x ||= case [row_num, col_num]
+        when [0, 0] # Left Up 
+          grid_x 
+        when [0, side_size] # Left Front 
+          grid_x+(side_size-1)*2*units
+        when [side_size, 0] # Left Left
+          grid_x
+        when [side_size, side_size] # Left Down 
+          grid_x+(side_size-1)*2*units
+        when [(side_size/2),(side_size/2)] # Left Center
+          grid_x
+        else
+          nil
+        end
+      end
+
+      def y
+        @y ||= case [row_num, col_num]
+        when [0, 0] # Left Up 
+          grid_y
+        when [0, side_size] # Left Front 
+          grid_y+(side_size-1)*units
+        when [side_size, 0] # Left Left
+          grid_y+(side_size-1)*2*units
+        when [side_size, side_size] # Left Down 
+          grid_y+(side_size)*2*units
+        when [(side_size/2),(side_size/2)] # Left Center
+          grid_y+(side_size/2)*units
+        else
+          nil
+        end
+      end
+
+      def points
+        case [row_num, col_num]
+        when [0, 0] # Left Up 
+          [
+            [ x, y ],
+            [ x+2*units, y+units ],
+            [ x, y+2*units ]
+          ]
+        when [0, side_size] # Left Front 
+          [
+            [ x, y ],
+            [ x+2*units, y+units ],
+            [ x+2*units, y+3*units ]
+          ]
+        when [side_size, 0] # Left Left
+          [
+            [ x, y ],
+            [ x+2*units, y+3*units ],
+            [ x, y+2*units ]
+          ]
+        when [side_size, side_size] # Left Down 
+          [
+            [ x+2*units, y ],
+            [ x+2*units, y+2*units ],
+            [ x, y+units ]
+          ]
+        when [(side_size/2), (side_size/2)] # Left Center
+          [
+            [ x+2*units, y ],
+            [ x+4*units, y+3*units ],
+            [ x+2*units, y+4*units ],
+            [ x, y+units ]
+          ]
+        else
+          nil
+        end
+      end
+
+      def build
+        GridGenerator::BaseElement.new(points: points, colour: colour, opacity: opacity)
+      end
+    end
+  end
+end

data/lib/grid_generator/skewb/left_skewb_grid.rb

@@ -0,0 +1,43 @@
+require './lib/grid_generator/skewb/skewb_grid.rb'
+require './lib/grid_generator/skewb/left_element_factory.rb'
+
+module GridGenerator
+  module Skewb
+    class LeftSkewbGrid < Skewb::SkewbGrid
+      def factory_class
+        GridGenerator::Skewb::LeftElementFactory
+      end
+  
+      def border_points
+        [
+          [ x, y ],
+          [ x + side_size*2*units, y + side_size*units ],
+          [ x + side_size*2*units, y + side_size*3*units ],
+          [ x, y + side_size*2*units ]
+        ]
+      end 
+  
+      def rows
+        Array.new(side_size) do |i|
+          { 
+            x1: x + (2*i)*units,
+            y1: y + (3*i+2)*units,
+            x2: x + (2*i+2)*units,
+            y2: y + (3*i+1)*units
+          }
+        end
+      end
+  
+      def columns
+        Array.new(side_size) do |i|
+          { 
+            x1: x + (2*i)*units,
+            y1: y + (-1*i+2)*units,
+            x2: x + (i+1)*2*units,
+            y2: y + (-1*i+5)*units
+          }
+        end
+      end
+    end
+  end
+end

data/lib/grid_generator/skewb/right_element_factory.rb

@@ -0,0 +1,90 @@
+module GridGenerator
+  module Skewb
+    class RightElementFactory
+      def initialize(grid_x:, grid_y:, row_num:, col_num:, side_size:, units:, colour:, opacity:)
+        @grid_x, @grid_y = grid_x, grid_y
+        @row_num, @col_num = row_num, col_num
+        @side_size, @units = side_size, units
+        @colour, @opacity = colour, opacity
+      end
+
+      attr_reader :grid_x, :grid_y, :row_num, :col_num, :side_size, :units, :colour, :opacity
+
+      def x
+        @x ||= case [row_num, col_num]
+        when [0, 0] # Right Front 
+          grid_x 
+        when [0, side_size] # Right Up 
+          grid_x+(side_size-1)*2*units
+        when [side_size, 0] # Right Down 
+          grid_x
+        when [side_size, side_size] # Right Right 
+          grid_x+(side_size-1)*2*units
+        when [(side_size/2),(side_size/2)] # Right Center
+          grid_x
+        else
+          nil
+        end
+      end
+
+      def y
+        @y ||= case [row_num, col_num]
+        when [0, 0] # Right Front 
+          grid_y+(side_size-1)*units
+        when [0, side_size] # Right Up 
+          grid_y
+        when [side_size, 0] # Right Down 
+          grid_y+(2*side_size)*units
+        when [side_size, side_size] # Right Right 
+          grid_y+(side_size-1)*2*units
+        when [(side_size/2),(side_size/2)] # Right Center
+          grid_y+(side_size/2)*units
+        else
+          nil
+        end
+      end
+
+      def points
+        case [row_num, col_num]
+        when [0, 0] # Right Front 
+          [
+            [ x, y+units ],
+            [ x+2*units, y ],
+            [ x, y+3*units ]
+          ]
+        when [0, side_size] # Right Up 
+          [
+            [ x, y+units ],
+            [ x+2*units, y ],
+            [ x+2*units, y+2*units ]
+          ]
+        when [side_size, 0] # Right Down 
+          [
+            [ x, y ],
+            [ x+2*units, y+units ],
+            [ x, y+2*units ]
+          ]
+        when [side_size, side_size] # Right Right 
+          [
+            [ x+2*units, y ],
+            [ x+2*units, y+2*units ],
+            [ x, y+3*units ]
+          ]
+        when [(side_size/2), (side_size/2)] # Right Center
+          [
+            [ x+2*units, y ],
+            [ x+4*units, y+units ],
+            [ x+2*units, y+4*units ],
+            [ x, y+3*units ]
+          ]
+        else
+          [] 
+        end
+      end
+
+      def build
+        GridGenerator::BaseElement.new(points: points, colour: colour, opacity: opacity) unless points.empty?
+      end
+    end
+  end
+end

data/lib/grid_generator/skewb/right_skewb_grid.rb

@@ -0,0 +1,43 @@
+require './lib/grid_generator/skewb/skewb_grid.rb'
+require './lib/grid_generator/skewb/right_element_factory.rb'
+
+module GridGenerator
+  module Skewb
+    class RightSkewbGrid < Skewb::SkewbGrid
+      def factory_class
+        GridGenerator::Skewb::RightElementFactory
+      end
+  
+      def border_points
+        [
+          [ x, y + side_size*units ],
+          [ x + side_size*2*units, y ],
+          [ x + side_size*2*units, y + side_size*2*units ],
+          [ x, y + side_size*3*units ]
+        ]
+      end 
+  
+      def rows
+        Array.new(side_size) do |i|
+          { 
+            x1: x + (2*i)*units,
+            y1: y + (i+4)*units,
+            x2: x + (2*i+2)*units,
+            y2: y + (i+1)*units
+          }
+        end
+      end
+  
+      def columns
+        Array.new(side_size) do |i|
+          { 
+            x1: x + (2*i)*units,
+            y1: y + (-3*i+4)*units,
+            x2: x + (i+1)*2*units,
+            y2: y + (-3*i+5)*units
+          }
+        end
+      end
+    end
+  end
+end