grid_generator 0.1.0

data/lib/grid_generator/skewb/skewb_grid.rb

@@ -0,0 +1,62 @@
+require './lib/grid_generator/face_parser'
+
+module GridGenerator
+  module Skewb
+    class SkewbGrid
+      def initialize(x:, y:, units: , elements: )
+        @x, @y = x, y
+        @units = units
+        @elements = case elements 
+        when String
+          FaceParser.new(elements).to_a
+        when Array
+          elements 
+        else
+          raise ArgumentError, "squares must be array or string"
+        end
+      end
+  
+      attr_reader :x, :y, :units, :elements
+  
+      def side_size 
+        elements.size - 1
+      end
+  
+      def build_element(row_num, col_num, data)
+        if data
+          factory_class.new(
+            grid_x: x,
+            grid_y: y,
+            row_num: row_num,
+            col_num: col_num,
+            side_size: side_size,
+            units: units,
+            colour: data[:colour],
+            opacity: data[:opacity]
+          ).build
+        else
+          nil
+        end
+      end
+  
+      def border_points_string
+        border_points.map { |x| x.join(',') }.join(' ') 
+      end
+  
+      def element_shapes
+        elements.each_with_index.map do |row, row_num|
+          row.each_with_index.map do |col, col_num|
+            build_element(row_num, col_num, col)
+          end
+        end.flatten.compact
+      end
+
+      def as_json
+        {
+          "border_points_string" => border_points_string,
+          "element_shapes" => element_shapes.map(&:as_json)
+        }
+      end
+    end
+  end
+end

data/lib/grid_generator/skewb/top_element_factory.rb

@@ -0,0 +1,90 @@
+module GridGenerator
+  module Skewb
+    class TopElementFactory
+      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] # Top Back 
+          grid_x+(side_size-1)*2*units 
+        when [0, side_size] # Top Right
+          grid_x+((side_size*2)-1)*2*units
+        when [side_size, 0] # Top Left
+          grid_x
+        when [side_size, side_size] # Top Front
+          grid_x+(side_size-1)*2*units
+        when [(side_size/2),(side_size/2)] # Top Center
+          grid_x+(side_size/2)*2*units
+        else
+          nil
+        end
+      end
+
+      def y
+        @y ||= case [row_num, col_num]
+        when [0, 0] # Top Back 
+          grid_y
+        when [0, side_size] # Top Right 
+          grid_y+(side_size-1)*units
+        when [side_size, 0] # Top Left
+          grid_y+(side_size-1)*units
+        when [side_size, side_size] # Top Front
+          grid_y+(side_size*2-1)*units
+        when [(side_size/2),(side_size/2)] # Top Center
+          grid_y+(side_size/2)*units
+        else
+          nil
+        end
+      end
+
+      def points
+        case [row_num, col_num]
+        when [0, 0] # Top Back
+          [
+            [ x+2*units, y ],
+            [ x+4*units, y+units ],
+            [ x, y+units ]
+          ]
+        when [0, side_size] # Top Right 
+          [
+            [ x, y ],
+            [ x+2*units, y+units ],
+            [ x, y+2*units ]
+          ]
+        when [side_size, 0] # Top Left
+          [
+            [ x+2*units, y ],
+            [ x+2*units, y+2*units ],
+            [ x, y+units ]
+          ]
+        when [side_size, side_size] # Top Front
+          [
+            [ x, y ],
+            [ x+4*units, y ],
+            [ x+2*units, y+units ]
+          ]
+        when [(side_size/2), (side_size/2)] # Top Center
+          [
+            [ x, y ],
+            [ x+4*units, y ],
+            [ x+4*units, y+2*units ],
+            [ x, y+2*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/top_skewb_grid.rb

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

data/lib/grid_generator/square_one/element.rb

@@ -0,0 +1,60 @@
+require 'matrix'
+
+module GridGenerator
+  module SquareOne
+    class Element 
+      def initialize(x:, y:, units:, offset: , colour: , opacity: )
+        @x, @y = x, y
+        @units = units
+        @offset = offset
+        @colour = colour
+        @opacity = opacity
+      end
+  
+      attr_reader :x, :y, :units, :offset, :colour, :opacity
+      
+      def ==(other)
+        self.x == other.x &&
+          self.y == other.y &&
+          self.units == other.units &&
+          self.colour == other.colour &&
+          self.opacity == other.opacity
+      end
+  
+      def offset_radians
+        offset*Math::PI/6
+      end
+  
+      def half_edge_width 
+        @half_edge_width ||= half_face_size * Math.tan(Math::PI/12) 
+      end
+  
+      def half_face_size 
+        @half_face_size ||= face_size / 2 
+      end
+  
+      def face_size
+        @face_size ||= 3 * units
+      end
+  
+      def rotation_point
+        Matrix.column_vector([x+half_face_size, y+half_face_size])
+      end
+  
+      def rotation_matrix
+        @rotation_matrix ||= Matrix[
+          [Math.cos(offset_radians), -1*Math.sin(offset_radians)], 
+          [Math.sin(offset_radians), Math.cos(offset_radians)]
+        ]
+      end
+  
+      def points
+        base_points.map { |p| (rotation_matrix * (p - rotation_point)) + rotation_point }
+      end
+  
+      def points_string
+        points.map { |p| "#{p[0,0].round},#{p[1,0].round}" }.join(' ')
+      end
+    end
+  end
+end

data/lib/grid_generator/square_one/element_factory.rb

@@ -0,0 +1,89 @@
+require 'matrix'
+require './lib/grid_generator/base_element'
+
+module GridGenerator
+  module SquareOne
+    class ElementFactory
+      def initialize(x: , y:, units:, shape:, offset:, colour:, opacity:)
+        @x, @y = x, y
+        @units = units
+        @shape = shape
+        @offset = offset
+        @colour = colour
+        @opacity = opacity
+      end
+
+      attr_reader :x, :y, :units, :shape, :offset, :colour, :opacity
+
+      def base_points
+        case shape
+        when :edge
+          [
+            Matrix.column_vector([x+half_face_size-half_edge_width, y]),
+            Matrix.column_vector([x+half_face_size+half_edge_width, y]),
+            Matrix.column_vector([x+half_face_size, y+half_face_size])
+          ]
+        when :corner
+          [
+            Matrix.column_vector([x+half_face_size+half_edge_width, y]),
+            Matrix.column_vector([x+face_size, y]),
+            Matrix.column_vector([x+face_size, y+half_face_size-half_edge_width]),
+            Matrix.column_vector([x+half_face_size, y+half_face_size])
+          ] 
+        when :middle
+          [
+            Matrix.column_vector([x+half_face_size+half_edge_width, y]),
+            Matrix.column_vector([x+face_size, y]),
+            Matrix.column_vector([x+face_size, y+face_size]),
+            Matrix.column_vector([x+half_face_size-half_edge_width, y+face_size])
+          ] 
+        when :middle_flipped
+          @base_points ||= [
+            Matrix.column_vector([x+half_face_size-half_edge_width, y]),
+            Matrix.column_vector([x+face_size, y]),
+            Matrix.column_vector([x+face_size, y+face_size]),
+            Matrix.column_vector([x+half_face_size+half_edge_width, y+face_size])
+          ] 
+        else
+          raise ArgumentError, "unknown face shape: #{edge}"
+        end
+      end
+
+      def offset_radians
+        offset*Math::PI/6
+      end
+
+      def half_edge_width 
+        @half_edge_width ||= half_face_size * Math.tan(Math::PI/12) 
+      end
+
+      def half_face_size 
+        @half_face_size ||= face_size / 2 
+      end
+
+      def face_size
+        @face_size ||= 3 * units
+      end
+
+      def rotation_point
+        Matrix.column_vector([x+half_face_size, y+half_face_size])
+      end
+
+      def rotation_matrix
+        @rotation_matrix ||= Matrix[
+          [Math.cos(offset_radians), -1*Math.sin(offset_radians)], 
+          [Math.sin(offset_radians), Math.cos(offset_radians)]
+        ]
+      end
+  
+
+      def points
+        base_points.map { |p| (rotation_matrix * (p - rotation_point)) + rotation_point }
+      end
+
+      def build
+        GridGenerator::BaseElement.new(points: points, colour: colour, opacity: opacity)
+      end
+    end
+  end
+end

data/lib/grid_generator/square_one/face.rb

@@ -0,0 +1,82 @@
+require './lib/grid_generator/square_one_face_parser'
+require './lib/grid_generator/square_one/element_factory'
+
+module GridGenerator
+  module SquareOne
+    class Face 
+      def initialize(x:, y: , units: , elements:, axis_direction: :forward)
+        @x, @y = x, y
+        @units = units
+        @elements = case elements 
+        when String
+          SquareOneFaceParser.new(elements).to_a
+        when Array
+          elements 
+        else
+          raise ArgumentError, "squares must be array or string" 
+        end
+        @axis_direction = axis_direction
+      end
+  
+      attr_reader :x, :y, :units, :elements, :axis_direction
+  
+      def half_edge_width 
+        @half_edge_width ||= half_face_size * Math.tan(Math::PI/12) 
+      end
+  
+      def half_face_size 
+        @half_face_size ||= face_size / 2 
+      end
+  
+      def face_size
+        @face_size ||= 3 * units
+      end
+  
+      def axis
+        if axis_direction == :back
+          back_axis
+        else
+          forward_axis
+        end
+      end
+  
+      def forward_axis
+        {
+          x1: x+half_face_size+half_edge_width,
+          y1: y,
+          x2: x+half_face_size-half_edge_width,
+          y2: y+face_size
+        }
+      end
+  
+      def back_axis
+        {
+          x1: x+half_face_size-half_edge_width,
+          y1: y,
+          x2: x+half_face_size+half_edge_width,
+          y2: y+face_size
+        }
+      end
+  
+      def element_shapes
+        elements.map do |element|
+          GridGenerator::SquareOne::ElementFactory.new(
+            x: x,
+            y: y,
+            units: units,
+            shape: element[:shape],
+            offset: element[:offset],
+            colour: element[:colour],
+            opacity: element[:opacity]
+          ).build
+        end
+      end
+
+      def as_json
+        {
+          "element_shapes" => element_shapes.map(&:as_json)
+        }
+      end
+    end
+  end
+end

data/lib/grid_generator/square_one_face_parser.rb

@@ -0,0 +1,61 @@
+module GridGenerator
+  class SquareOneFaceParser
+    COLOURS = { 
+      'w' => '#ffffff',
+      'y' => '#ffff00',
+      'b' => '#0000ff',
+      'g' => '#00ff00',
+      'r' => '#ff0000',
+      'o' => '#ff8000',
+      'f' => '#d0d0d0'
+    } 
+  
+    OPACITY = {
+      full: 1,
+      faded: 0.4
+    }
+  
+    SHAPES = {
+      'e' => :edge,
+      'c' => :corner,
+      'm' => :middle,
+      'f' => :middle_flipped
+    }
+  
+    ELEMENT_DEFINITION = /(e|c|m|f)(\d+)([a-zA-Z])/
+  
+    def initialize(string)
+      @string = string
+    end
+  
+    attr_reader :string
+  
+    def to_a
+      string.split(',').map(&:strip).map do |col|
+        shape_def, offset_def, colour_def = ELEMENT_DEFINITION.match(col).captures 
+        {
+          shape: shape(shape_def),
+          offset: offset(offset_def),
+          colour: colour(colour_def),
+          opacity: opacity(colour_def)
+        }
+      end
+    end
+  
+    def shape(definition)
+      SHAPES[definition]
+    end
+  
+    def offset(definition)
+      definition.to_i
+    end
+  
+    def colour(definition)
+      COLOURS[definition.downcase]
+    end
+  
+    def opacity(definition)
+      OPACITY[(/[[:upper:]]/.match(definition) ? :full : :faded)]
+    end
+  end
+end

data/lib/grid_generator/version.rb

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

data/lib/grid_generator.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "grid_generator/version"
+
+require './lib/grid_generator/cubic/iso_view.rb'
+require './lib/grid_generator/cubic/top_grid'
+require './lib/grid_generator/cubic/front_grid'
+require './lib/grid_generator/cubic/right_grid'
+require './lib/grid_generator/cubic/facing_grid'
+require './lib/grid_generator/cubic/bordered_grid'
+require './lib/grid_generator/cubic/square_factory'
+require './lib/grid_generator/skewb/top_skewb_grid'
+require './lib/grid_generator/skewb/left_skewb_grid'
+require './lib/grid_generator/skewb/right_skewb_grid'
+require './lib/grid_generator/square_one/face'
+require './lib/grid_generator/arrows/vertical_arrow'
+require './lib/grid_generator/arrows/horizontal_arrow'
+require './lib/grid_generator/arrows/diagonal_down_arrow'
+require './lib/grid_generator/arrows/diagonal_up_arrow'
+require './lib/grid_generator/pyraminx/grid'
+require './lib/grid_generator/megaminx/face'
+
+module GridGenerator
+  def self.iso_view(args)
+    Cubic::IsoView.new(**args)
+  end
+
+  def self.top_grid(args)
+    Cubic::TopGrid.new(**args)
+  end
+
+  def self.front_grid(args)
+    Cubic::FrontGrid.new(**args)
+  end
+
+  def self.right_grid(args)
+    Cubic::RightGrid.new(**args)
+  end
+
+  def self.facing_grid(args)
+    Cubic::FacingGrid.new(**args)
+  end
+
+  def self.bordered_grid(args)
+    Cubic::BorderedGrid.new(**args)
+  end
+
+  def self.top_square(args)
+    #??
+    Cubic::TopSquareFactory.new(**args).build
+  end
+
+  def self.front_square(args)
+    #??
+    Cubic::FrontSquareFactory.new(**args).build
+  end
+
+  def self.right_square(args)
+    #??
+    Cubic::RightSquareFactory.new(**args).build
+  end
+
+  def self.top_skewb_grid(args)
+    Skewb::TopSkewbGrid.new(**args)
+  end
+
+  def self.left_skewb_grid(args)
+    Skewb::LeftSkewbGrid.new(**args)
+  end
+
+  def self.right_skewb_grid(args)
+    Skewb::RightSkewbGrid.new(**args)
+  end
+
+  def self.square_one_face(args)
+    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_grid(args)
+    Pyraminx::Grid.new(**args)
+  end
+
+  def self.pyraminx_triangle(args)
+    Pyraminx::Triangle.new(**args)
+  end
+
+  def self.megaminx_face(args)
+    Megaminx::Face.new(**args)
+  end
+end
+

data/sig/grid_generator.rbs

@@ -0,0 +1,4 @@
+module GridGenerator
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end