grid_generator 0.2.23 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84401ca268f2dd6e73aa1cf880a9b534ca81291c5576f044e1494b5684aa0f26
-  data.tar.gz: 6c00e9248134a87f8751bd436a850e8467bfc65966c6ed7544640fc9b28130fa
+  metadata.gz: d75cdb06a79ebb644afccc577353a18b2a7f999251ffffd6f1f7617b08c23745
+  data.tar.gz: fb3fc73597223fed891b6857250e217f9c4ca057e1795574b2ae1a9fd2ce1c41
 SHA512:
-  metadata.gz: 4ddbe0d8f15c45aa80ae209ed4e348d3d6c02a2c41a99cad2103a783267b487999034c1cc641c0ccbf6b30d97e3d34349f7165102713d7bdbbbc136ada17ec58
-  data.tar.gz: f7b7aac3f4daf48485de2f9d395c341bb40d84495e57825b468810b26b13e4f09d3d4928d46af2650d6fdff24db7b3325957ebae84e589a09e79b93d2d836dfc
+  metadata.gz: 06f2a4c827b2710abc6a379f6a45360a7caabafa4b0905f466e975968c0a622bb1f87296d7409b6225dabc7f807f126b4c93633af4b8a449830eb27703a5aee7
+  data.tar.gz: 1cb5b6a79655216376731edcd9724ceb9dd9cb5e6236df9cab39c8e048754a0aca33a17413a71d87aeb8985c48a74ad0500ac8f1035b2c7784a948db9b3f3976

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    grid_generator (0.2.23)
+    grid_generator (0.3.0)
       matrix (~> 0.4.2)
 
 GEM

data/lib/grid_generator/face_parser.rb

@@ -9,7 +9,7 @@ module GridGenerator
       'o' => '#ffb000',
       'gr' => '#808080',
       'br' => '#804000',
-      's' => '#8080ff',
+      's' => '#8080ff', # change to sand colour
       'l' => '#80ff80',
       'p' => '#800080', 
       'pi' => '#ff8080',

data/lib/grid_generator/megaminx/face_element_factory.rb

@@ -3,7 +3,7 @@ require_relative '../face_parser'
 module GridGenerator
   module Megaminx
     class FaceElementFactory
-      def initialize(x:, y:, index:, face_points: , face_lines:, face:)
+      def initialize(x:, y:, index:, face_points: , face_lines:, face:, rotator: )
         @x, @y = x, y
         @index = index
         @face_points = face_points
@@ -11,9 +11,10 @@ module GridGenerator
         face_attr = FaceParser.new(face).parse
         @colour = face_attr && face_attr[:colour]
         @opacity = face_attr && face_attr[:opacity]
+        @rotator = rotator 
       end
 
-      attr_reader :x, :y, :index, :face_points, :face_lines, :colour, :opacity 
+      attr_reader :x, :y, :index, :face_points, :face_lines, :colour, :opacity, :rotator 
 
       def offset
         Matrix.column_vector([x, y])
@@ -81,7 +82,7 @@ module GridGenerator
           end
         end
 
-        all_points.map { |p| p + offset }
+        all_points.map { |p| rotator.rotate(p) + offset }
       end
 
       def build

data/lib/grid_generator/megaminx/face_projection.rb

@@ -99,12 +99,8 @@ module GridGenerator
 
       def outside_pentagon_points
         @outside_pentagon_points ||= (0..4).map do |i|
-          if i == 0
-            top_right_pentagon_points 
-          else
-            rotator = GridGenerator::Rotator.new(angle: Math::PI * i * 0.4, rotation_point: rotation_point)
-            top_right_pentagon_points.map { |p| rotator.rotate(p) } 
-          end
+          rotator = GridGenerator::Rotator.new(angle: Math::PI * i * 0.4, rotation_point: rotation_point)
+          top_right_pentagon_points.map { |p| rotator.rotate(p) } 
         end
       end
 
@@ -138,12 +134,8 @@ module GridGenerator
 
       def outside_face_lines_raw
         @outside_face_lines_raw ||= (0..4).map do |i|
-          if i == 0
-            top_right_face_lines_raw
-          else
-            rotator = GridGenerator::Rotator.new(angle: Math::PI * i * 0.4, rotation_point: rotation_point)
-            top_right_face_lines_raw.map { |l| rotator.rotate(l) } 
-          end
+          rotator = GridGenerator::Rotator.new(angle: Math::PI * i * 0.4, rotation_point: rotation_point)
+          top_right_face_lines_raw.map { |l| rotator.rotate(l) } 
         end
       end
 
@@ -154,31 +146,31 @@ module GridGenerator
 
       # for svg
       def decagon_points_string
-        decagon_points.map { |p| p + offset }.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
+        decagon_points.map { |p| offset_rotator.rotate(p) + offset }.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
       end
 
       # for svg
       def pentagon_points_string
-        pentagon_points.map { |p| p + offset }.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
+        pentagon_points.map { |p| offset_rotator.rotate(p) + offset }.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
       end
 
       # for svg
       def connecting_lines
         pentagon_points.each_with_index.map do |p, i|
           d = decagon_points[i*2]
-          GridGenerator::Line.new(a: p, b: d) + offset
+          offset_rotator.rotate(GridGenerator::Line.new(a: p, b: d)) + offset
         end
       end
 
       # for svg
       def front_face_lines
-        front_face_lines_raw.map { |l| l + offset }
+        front_face_lines_raw.map { |l| offset_rotator.rotate(l) + offset }
       end
 
       # for svg
       def outside_face_lines
         outside_face_lines_raw.map do |face_lines|
-          face_lines.map { |l| l + offset }
+          face_lines.map { |l| offset_rotator.rotate(l) + offset }
         end
       end
 
@@ -191,7 +183,8 @@ module GridGenerator
             index: i,
             face_points: pentagon_points,
             face_lines: front_face_lines_raw,
-            face: element
+            face: element,
+            rotator: offset_rotator
           ).build unless element == '-'
         end.compact
       end
@@ -206,7 +199,8 @@ module GridGenerator
               index: element_index,
               face_points: outside_pentagon_points[face_index],
               face_lines: outside_face_lines_raw[face_index],
-              face: element
+              face: element,
+              rotator: offset_rotator
             ).build unless element == '-'
           end.compact
         end

data/lib/grid_generator/rotator.rb

@@ -13,6 +13,7 @@ module GridGenerator
 
     # subtract rotation point to move point towards 0,0, rotate, then add to move back
     def rotate(obj)
+      return obj if angle == 0 
       case obj
       when Matrix
         (matrix * (obj - rotation_point)) + rotation_point

data/lib/grid_generator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GridGenerator
-  VERSION = "0.2.23"
+  VERSION = "0.3.0"
 end

data/lib/grid_generator.rb

@@ -13,12 +13,7 @@ require_relative 'grid_generator/skewb/top_skewb_grid'
 require_relative 'grid_generator/skewb/left_skewb_grid'
 require_relative 'grid_generator/skewb/right_skewb_grid'
 require_relative 'grid_generator/square_one/face'
-require_relative 'grid_generator/arrows/vertical_arrow'
-require_relative 'grid_generator/arrows/horizontal_arrow'
-require_relative 'grid_generator/arrows/diagonal_down_arrow'
-require_relative 'grid_generator/arrows/diagonal_up_arrow'
 require_relative 'grid_generator/pyraminx/face'
-require_relative 'grid_generator/megaminx/face'
 require_relative 'grid_generator/megaminx/face_projection'
 
 module GridGenerator
@@ -65,30 +60,10 @@ module GridGenerator
     SquareOne::Face.new(**args)
   end
 
-  def self.vertical_arrow(args)
-    Arrows::VerticalArrow.new(**args)
-  end
-
-  def self.horizontal_arrow(args)
-    Arrows::HorizontalArrow.new(**args)
-  end
-
-  def self.diagonal_down_arrow(args)
-    Arrows::DiagonalDownArrow.new(**args)
-  end
-
-  def self.diagonal_up_arrow(args)
-    Arrows::DiagonalUpArrow.new(**args)
-  end
-
   def self.pyraminx_face(args)
     Pyraminx::Face.new(**args)
   end
 
-  def self.megaminx_face(args)
-    Megaminx::Face.new(**args)
-  end
-
   def self.megaminx_face_projection(args)
     Megaminx::FaceProjection.new(**args)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grid_generator
 version: !ruby/object:Gem::Version
-  version: 0.2.23
+  version: 0.3.0
 platform: ruby
 authors:
 - Mark Humphreys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-07 00:00:00.000000000 Z
+date: 2023-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: matrix
@@ -40,11 +40,6 @@ files:
 - Rakefile
 - grid_generator.gemspec
 - lib/grid_generator.rb
-- lib/grid_generator/arrows/arrow.rb
-- lib/grid_generator/arrows/diagonal_down_arrow.rb
-- lib/grid_generator/arrows/diagonal_up_arrow.rb
-- lib/grid_generator/arrows/horizontal_arrow.rb
-- lib/grid_generator/arrows/vertical_arrow.rb
 - lib/grid_generator/base_element.rb
 - lib/grid_generator/cubic/bordered_grid.rb
 - lib/grid_generator/cubic/facing_grid.rb
@@ -59,12 +54,8 @@ files:
 - lib/grid_generator/face_parser.rb
 - lib/grid_generator/helper.rb
 - lib/grid_generator/line.rb
-- lib/grid_generator/megaminx/common.rb
-- lib/grid_generator/megaminx/element_factory.rb
-- lib/grid_generator/megaminx/face.rb
 - lib/grid_generator/megaminx/face_element_factory.rb
 - lib/grid_generator/megaminx/face_projection.rb
-- lib/grid_generator/megaminx/front_face.rb
 - lib/grid_generator/pyraminx/face.rb
 - lib/grid_generator/pyraminx/triangle_factory.rb
 - lib/grid_generator/rotator.rb

data/lib/grid_generator/arrows/arrow.rb

@@ -1,29 +0,0 @@
-module GridGenerator
-  module Arrows
-    class Arrow
-      def initialize(x:, y:, length:, direction: :uni, colour: '#ffffff')
-        @x, @y = x, y
-        @length = length
-        @direction = direction
-        @colour = colour
-      end
-    
-      attr_reader :x, :y, :length, :direction, :colour
-    
-      def points
-        []
-      end
-    
-      def points_string
-        points.map { |p| p.join(',') }.join(' ')
-      end
-
-      def as_json
-        {
-          "points_string" => points_string,
-          "colour" => colour
-        }
-      end
-    end
-  end
-end

data/lib/grid_generator/arrows/diagonal_down_arrow.rb

@@ -1,65 +0,0 @@
-require_relative 'arrow'
-
-module GridGenerator
-  module Arrows
-    class DiagonalDownArrow < Arrow
-      ARROW_SIDE = 12
-      ARROW_OVERHANG = 4 
-    
-      def arrow_start_point
-        [
-          [ x, y+ARROW_SIDE ],
-          [ x, y ],
-          [ x+ARROW_SIDE, y ]
-        ]
-      end
-    
-      def arrow_start_flat
-        [
-          [ x, y+ARROW_SIDE-(2*ARROW_OVERHANG) ],
-          [ x+ARROW_SIDE-(2*ARROW_OVERHANG), y ]
-        ]
-      end
-    
-      def arrow_start_side
-        [
-          [ x+ARROW_SIDE-ARROW_OVERHANG, y+ARROW_OVERHANG ],
-          [ x+(ARROW_SIDE-ARROW_OVERHANG)+length, y+length+ARROW_OVERHANG ]
-        ]
-      end
-    
-      def arrow_end_point
-        [
-          [ x+ARROW_SIDE+length, y+length ],
-          [ x+ARROW_SIDE+length, y+ARROW_SIDE+length ],
-          [ x+length, y+ARROW_SIDE+length ]
-        ]
-      end
-    
-      def arrow_end_flat
-        [
-          [ x+ARROW_SIDE+length, y+length+(2*ARROW_OVERHANG) ],
-          [ x+length+(2*ARROW_OVERHANG), y+ARROW_SIDE+length ]
-        ]
-      end
-    
-      def arrow_end_side
-        [
-          [ x+length+ARROW_OVERHANG, y+ARROW_SIDE+length-ARROW_OVERHANG ],
-          [ x+ARROW_OVERHANG, y+ARROW_SIDE-ARROW_OVERHANG ]
-        ]
-      end
-    
-      def points
-        case direction
-        when :forward
-          arrow_start_flat + arrow_start_side + arrow_end_point + arrow_end_side
-        when :backward
-          arrow_start_point + arrow_start_side + arrow_end_flat + arrow_end_side
-        else
-          arrow_start_point + arrow_start_side + arrow_end_point + arrow_end_side
-        end
-      end
-    end
-  end
-end

data/lib/grid_generator/arrows/diagonal_up_arrow.rb

@@ -1,66 +0,0 @@
-require_relative 'arrow'
-
-module GridGenerator
-  module Arrows
-    class DiagonalUpArrow < Arrow
-      ARROW_SIDE = 12
-      ARROW_OVERHANG = 4 
-    
-      def arrow_start_point
-        [
-          [ x+ARROW_SIDE, y+length+ARROW_SIDE ],
-          [ x, y+length+ARROW_SIDE ],
-          [ x, y+length ]
-        ]
-      end
-    
-      def arrow_start_flat
-        [
-          [ x+ARROW_SIDE-(2*ARROW_OVERHANG), y+length+ARROW_SIDE ],
-          [ x, y+length+(2*ARROW_OVERHANG) ]
-        ]
-      end
-    
-      def arrow_start_side
-        [
-          [ x+ARROW_OVERHANG, y+length+ARROW_OVERHANG ],
-          [ x+length+ARROW_OVERHANG, y+ARROW_OVERHANG ]
-        ]
-      end
-    
-      def arrow_end_point
-        [
-          [ x+length, y ],
-          [ x+length+ARROW_SIDE, y ],
-          [ x+length+ARROW_SIDE, y+ARROW_SIDE ]
-        ]
-      end
-    
-      def arrow_end_flat
-        [
-          [ x+length+(2*ARROW_OVERHANG), y ],
-          [ x+length+ARROW_SIDE, y+ARROW_SIDE-(2*ARROW_OVERHANG) ]
-        ]
-      end
-    
-      def arrow_end_side
-        [
-          [ x+length+ARROW_SIDE-ARROW_OVERHANG, y+ARROW_SIDE-ARROW_OVERHANG ],
-          [ x+ARROW_SIDE-ARROW_OVERHANG, y+length+ARROW_SIDE-ARROW_OVERHANG ]
-        ]
-      end
-    
-      def points
-        case direction
-        when :forward
-          arrow_start_flat + arrow_start_side + arrow_end_point + arrow_end_side
-        when :backward
-          arrow_start_point + arrow_start_side + arrow_end_flat + arrow_end_side
-        else
-          arrow_start_point + arrow_start_side + arrow_end_point + arrow_end_side
-        end
-      end
-    
-    end
-  end
-end

data/lib/grid_generator/arrows/horizontal_arrow.rb

@@ -1,66 +0,0 @@
-require_relative 'arrow'
-
-module GridGenerator
-  module Arrows
-    class HorizontalArrow < Arrow
-      ARROW_WIDTH = 16
-      ARROW_LENGTH = 8
-      LINE_WIDTH = 6
-    
-      def arrow_start_point
-        [
-          [ x+ARROW_LENGTH, y+ARROW_WIDTH ],
-          [ x, y+(ARROW_WIDTH/2) ],
-          [ x+ARROW_LENGTH, y ]
-        ]
-      end
-    
-      def arrow_start_flat
-        [
-          [ x, y+(ARROW_WIDTH/2)+(LINE_WIDTH/2) ],
-          [ x, y+(ARROW_WIDTH/2)-(LINE_WIDTH/2) ]
-        ]
-      end
-    
-      def arrow_start_side
-        [
-          [ x+ARROW_LENGTH, y+(ARROW_WIDTH/2)-(LINE_WIDTH/2) ],
-          [ x+ARROW_LENGTH+length, y+(ARROW_WIDTH/2)-(LINE_WIDTH/2) ]
-        ]
-      end
-    
-      def arrow_end_point
-        [
-          [ x+ARROW_LENGTH+length, y ],
-          [ x+(2*ARROW_LENGTH)+length, y+(ARROW_WIDTH/2) ],
-          [ x+ARROW_LENGTH+length, y+ARROW_WIDTH ]
-        ]
-      end
-    
-      def arrow_end_flat
-        [
-          [ x+(2*ARROW_LENGTH)+length, y+(ARROW_WIDTH/2)-(LINE_WIDTH/2) ],
-          [ x+(2*ARROW_LENGTH)+length, y+(ARROW_WIDTH/2)+(LINE_WIDTH/2) ]
-        ]
-      end
-    
-      def arrow_end_side
-        [
-          [ x+ARROW_LENGTH+length, y+(ARROW_WIDTH/2)+(LINE_WIDTH/2) ],
-          [ x+ARROW_LENGTH, y+(ARROW_WIDTH/2)+(LINE_WIDTH/2) ]
-        ]
-      end 
-    
-      def points
-        case direction
-        when :forward
-          arrow_start_flat + arrow_start_side + arrow_end_point + arrow_end_side
-        when :backward
-          arrow_start_point + arrow_start_side + arrow_end_flat + arrow_end_side
-        else
-          arrow_start_point + arrow_start_side + arrow_end_point + arrow_end_side
-        end
-      end
-    end
-  end
-end

data/lib/grid_generator/arrows/vertical_arrow.rb

@@ -1,66 +0,0 @@
-require_relative 'arrow'
-
-module GridGenerator
-  module Arrows
-    class VerticalArrow < Arrow
-      ARROW_WIDTH = 16
-      ARROW_LENGTH = 8
-      LINE_WIDTH = 6
-    
-      def arrow_start_point
-        [
-          [ x, y+ARROW_LENGTH ],
-          [ x+(ARROW_WIDTH/2), y ],
-          [ x+ARROW_WIDTH, y+ARROW_LENGTH ]
-        ]
-      end
-    
-      def arrow_start_flat
-        [
-          [ x+(ARROW_WIDTH/2)-(LINE_WIDTH/2), y ],
-          [ x+(ARROW_WIDTH/2)+(LINE_WIDTH/2), y ]
-        ]
-      end
-    
-      def arrow_start_side
-        [
-          [ x+(ARROW_WIDTH/2)+(LINE_WIDTH/2), y+ARROW_LENGTH ],
-          [ x+(ARROW_WIDTH/2)+(LINE_WIDTH/2), y+ARROW_LENGTH+length ]
-        ]
-      end
-    
-      def arrow_end_point
-        [
-          [ x+ARROW_WIDTH, y+ARROW_LENGTH+length ],
-          [ x+(ARROW_WIDTH/2), y+(ARROW_LENGTH*2)+length ],
-          [ x, y+ARROW_LENGTH+length ]
-        ]
-      end
-    
-      def arrow_end_flat
-        [
-          [ x+(ARROW_WIDTH/2)+(LINE_WIDTH/2), y+(2*ARROW_LENGTH)+length ],
-          [ x+(ARROW_WIDTH/2)-(LINE_WIDTH/2), y+(2*ARROW_LENGTH)+length ]
-        ]
-      end
-    
-      def arrow_end_side
-        [
-          [ x+(ARROW_WIDTH/2)-(LINE_WIDTH/2), y+ARROW_LENGTH+length ],
-          [ x+(ARROW_WIDTH/2)-(LINE_WIDTH/2), y+ARROW_LENGTH ]
-        ]
-      end
-    
-      def points
-        case direction
-        when :forward
-          arrow_start_flat + arrow_start_side + arrow_end_point + arrow_end_side
-        when :backward
-          arrow_start_point + arrow_start_side + arrow_end_flat + arrow_end_side
-        else
-          arrow_start_point + arrow_start_side + arrow_end_point + arrow_end_side
-        end
-      end
-    end
-  end
-end

data/lib/grid_generator/megaminx/common.rb

@@ -1,95 +0,0 @@
-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

@@ -1,52 +0,0 @@
-require_relative '../base_element'
-require_relative '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

@@ -1,79 +0,0 @@
-require_relative '../face_parser'
-require_relative 'common'
-require_relative '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).parse
-        @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/megaminx/front_face.rb

@@ -1,12 +0,0 @@
-class GridGenerator
-  module Megaminx
-    class FrontFace
-      def (x:, y:, units:, elements:)
-        @x, @y = x, y
-        @units = units
-        @elements = elements
-      end
-
-    end
-  end
-end