twisty_puzzles 0.0.1

data/lib/twisty_puzzles/cube_move_parser.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/abstract_direction'
+require 'twisty_puzzles/abstract_move_parser'
+require 'twisty_puzzles/cube'
+require 'twisty_puzzles/cube_constants'
+require 'twisty_puzzles/cube_move'
+require 'twisty_puzzles/move_type_creator'
+require 'twisty_puzzles/rotation'
+require 'twisty_puzzles/skewb_move'
+
+module TwistyPuzzles
+  
+    # Parser for cube moves.
+    class CubeMoveParser < AbstractMoveParser
+      REGEXP =
+        begin
+                        axes_part = "(?<axis_name>[#{AbstractMove::AXES.join}])"
+                        face_names = CubeConstants::FACE_NAMES.join
+                        fat_move_part =
+                          "(?<width>\\d*)(?<fat_face_name>[#{face_names}])w"
+                        normal_move_part = "(?<face_name>[#{face_names}])"
+                        downcased_face_names = face_names.downcase
+                        maybe_fat_maybe_slice_move_part =
+                          "(?<maybe_fat_face_maybe_slice_name>[#{downcased_face_names}])"
+                        slice_move_part =
+                          "(?<slice_index>\\d+)(?<slice_name>[#{downcased_face_names}])"
+                        mslice_move_part =
+                          "(?<mslice_name>[#{AbstractMove::SLICE_FACES.keys.join}])"
+                        move_part = "(?:#{axes_part}|" \
+                                    "#{fat_move_part}|" \
+                                    "#{normal_move_part}|" \
+                                    "#{maybe_fat_maybe_slice_move_part}|" \
+                                    "#{slice_move_part}|#{mslice_move_part})"
+                        direction_names =
+                          AbstractDirection::POSSIBLE_DIRECTION_NAMES.flatten
+                        direction_names.sort_by! { |e| -e.length }
+                        direction_part = "(?<direction>#{direction_names.join('|')})"
+                        Regexp.new("#{move_part}#{direction_part}")
+                      end
+
+      MOVE_TYPE_CREATORS = [
+        MoveTypeCreator.new(%i[axis_face direction], Rotation),
+        MoveTypeCreator.new(%i[fat_face direction width], FatMove),
+        MoveTypeCreator.new(%i[face direction], FatMove),
+        MoveTypeCreator.new(%i[maybe_fat_face_maybe_slice_face direction], MaybeFatMaybeSliceMove),
+        MoveTypeCreator.new(%i[slice_face direction slice_index], SliceMove),
+        MoveTypeCreator.new(%i[mslice_face direction], MaybeFatMSliceMaybeInnerMSliceMove)
+      ].freeze
+
+      INSTANCE = CubeMoveParser.new
+      def regexp
+        REGEXP
+      end
+
+      def move_type_creators
+        MOVE_TYPE_CREATORS
+      end
+
+      def parse_part_key(name)
+        name.sub('_name', '_face').sub('face_face', 'face')
+      end
+
+      def parse_direction(direction_string)
+        value = AbstractDirection::POSSIBLE_DIRECTION_NAMES.index do |ds|
+          ds.include?(direction_string)
+        end + 1
+        CubeDirection.new(value)
+      end
+
+      def parse_axis_face(axis_face_string)
+        Face::ELEMENTS[AbstractMove::AXES.index(axis_face_string)]
+      end
+
+      def parse_mslice_face(mslice_name)
+        AbstractMove::SLICE_FACES[mslice_name]
+      end
+
+      def parse_width(width_string)
+        width_string.empty? ? 2 : Integer(width_string, 10)
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def parse_move_part(name, value)
+        case name
+        when 'axis_name' then parse_axis_face(value)
+        when 'width' then parse_width(value)
+        when 'slice_index' then Integer(value, 10)
+        when 'fat_face_name', 'face_name' then Face.by_name(value)
+        when 'maybe_fat_face_maybe_slice_name', 'slice_name'
+          Face.by_name(value.upcase)
+        when 'mslice_name'
+          parse_mslice_face(value)
+        when 'direction' then parse_direction(value)
+        else raise
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+    end
+end

data/lib/twisty_puzzles/cube_print_helper.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'twisty_puzzles/utils/array_helper'
+
+module TwistyPuzzles
+  
+    # Module to print and display cube and Skewb states.
+    module CubePrintHelper
+      include Utils::ArrayHelper
+
+      def color_symbol(color)
+        case color
+        when :orange then :light_red
+        when :unknown then :light_black
+        else color
+        end
+      end
+
+      COLOR_MODES = %i[color nocolor].freeze
+      ColorInfo = Struct.new(:reverse_lines_mode, :reverse_columns_mode, :skewb_corner_permutation)
+      FACE_SYMBOL_INFOS = {
+        U: ColorInfo.new(:reverse, :reverse, [2, 3, 0, 1]),
+        L: ColorInfo.new(:keep, :reverse, [2, 0, 3, 1]),
+        F: ColorInfo.new(:keep, :reverse, [2, 0, 3, 1]),
+        R: ColorInfo.new(:keep, :keep, [1, 0, 3, 2]),
+        B: ColorInfo.new(:keep, :keep, [1, 0, 3, 2]),
+        D: ColorInfo.new(:keep, :reverse, [2, 0, 3, 1])
+      }.freeze
+
+      def color_character(color, color_mode)
+        unless COLOR_MODES.include?(color_mode)
+          raise ArgumentError, "Invalid color mode #{color_mode}"
+        end
+
+        char = color.to_s[0].upcase
+        if color_mode == :color
+          char.colorize(background: color_symbol(color))
+        else
+          char
+        end
+      end
+
+      def maybe_reverse(reverse_mode, stuff)
+        if reverse_mode == :reverse
+          stuff.reverse
+        elsif reverse_mode == :keep
+          stuff
+        else
+          raise
+        end
+      end
+
+      def face_lines(cube_state, face_symbol, row_multiplicity = 1, column_multiplicity = 1)
+        face = Face.for_face_symbol(face_symbol)
+        face_symbol_info = FACE_SYMBOL_INFOS[face_symbol]
+        stickers = cube_state.sticker_array(face)
+        lines =
+          stickers.collect_concat do |sticker_line|
+            line = sticker_line.map { |c| yield(c) * column_multiplicity }
+            [maybe_reverse(face_symbol_info.reverse_columns_mode, line).join] * row_multiplicity
+          end
+        maybe_reverse(face_symbol_info.reverse_lines_mode, lines)
+      end
+
+      def simple_face_lines(cube_state, face_symbol, color_mode)
+        face_lines(cube_state, face_symbol) { |c| color_character(c, color_mode) }
+      end
+
+      SKEWB_FACE_SIZE = 5
+
+      def skewb_ascii_art_line(first_color, middle_color, last_color, num_first_color)
+        raise if num_first_color > SKEWB_FACE_SIZE / 2
+
+        first_color * num_first_color +
+          middle_color * (SKEWB_FACE_SIZE - 2 * num_first_color) +
+          last_color * num_first_color
+      end
+
+      def skewb_ascii_art(center_color, corner_colors)
+        raise unless corner_colors.length == 4
+
+        first_part =
+          (1..SKEWB_FACE_SIZE / 2).to_a.reverse.map do |i|
+            skewb_ascii_art_line(corner_colors[0], center_color, corner_colors[1], i)
+          end
+        middle_part = SKEWB_FACE_SIZE.odd? ? [center_color * SKEWB_FACE_SIZE] : []
+        last_part =
+          (1..SKEWB_FACE_SIZE / 2).map do |i|
+            skewb_ascii_art_line(corner_colors[2], center_color, corner_colors[3], i)
+          end
+        first_part + middle_part + last_part
+      end
+
+      # Prints a Skewb face like this:
+      # rrgww
+      # rgggw
+      # ggggg
+      # ogggb
+      # oogbb
+      def skewb_face_lines(cube_state, face_symbol, color_mode)
+        face = Face.for_face_symbol(face_symbol)
+        face_symbol_info = FACE_SYMBOL_INFOS[face_symbol]
+        stickers = cube_state.sticker_array(face)
+        center_color = color_character(stickers[0], color_mode)
+        corner_colors = stickers[1..-1].map { |c| color_character(c, color_mode) }
+        permuted_corner_colors =
+          apply_permutation(corner_colors, face_symbol_info.skewb_corner_permutation)
+        raise unless corner_colors.length == 4
+
+        skewb_ascii_art(center_color, permuted_corner_colors)
+      end
+
+      def ll_string(cube_state, color_mode)
+        top_face = face_lines(cube_state, :U, 2, 3) { |c| color_character(c, color_mode) }
+        front_face = face_lines(cube_state, :F, 1, 3) { |c| color_character(c, color_mode) }
+        right_face = face_lines(cube_state, :R, 1, 3) { |c| color_character(c, color_mode) }
+        pll_line = front_face.first + right_face.first
+        (top_face + [pll_line] * 3).join("\n")
+      end
+
+      def cube_string(cube_state, color_mode)
+        top_face = simple_face_lines(cube_state, :U, color_mode)
+        left_face = simple_face_lines(cube_state, :L, color_mode)
+        front_face = simple_face_lines(cube_state, :F, color_mode)
+        right_face = simple_face_lines(cube_state, :R, color_mode)
+        back_face = simple_face_lines(cube_state, :B, color_mode)
+        bottom_face = simple_face_lines(cube_state, :D, color_mode)
+        middle_belt = zip_concat_lines(left_face, front_face, right_face, back_face)
+        lines = pad_lines(top_face, cube_state.n) + middle_belt +
+                pad_lines(bottom_face, cube_state.n)
+        lines.join("\n")
+      end
+
+      def skewb_string(skewb_state, color_mode)
+        top_face = skewb_face_lines(skewb_state, :U, color_mode)
+        left_face = skewb_face_lines(skewb_state, :L, color_mode)
+        front_face = skewb_face_lines(skewb_state, :F, color_mode)
+        right_face = skewb_face_lines(skewb_state, :R, color_mode)
+        back_face = skewb_face_lines(skewb_state, :B, color_mode)
+        bottom_face = skewb_face_lines(skewb_state, :D, color_mode)
+        middle_belt = zip_concat_lines(left_face, front_face, right_face, back_face)
+        lines = pad_lines(top_face, SKEWB_FACE_SIZE) + middle_belt +
+                pad_lines(bottom_face, SKEWB_FACE_SIZE)
+        lines.join("\n")
+      end
+
+      def empty_name
+        ' '
+      end
+
+      def pad_lines(lines, padding)
+        lines.map { |line| empty_name * padding + line }
+      end
+
+      def zip_concat_lines(*args)
+        args.transpose.map(&:join)
+      end
+    end
+end

data/lib/twisty_puzzles/cube_state.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/cube'
+require 'twisty_puzzles/cube_constants'
+require 'twisty_puzzles/coordinate'
+require 'twisty_puzzles/cube_print_helper'
+require 'twisty_puzzles/state_helper'
+require 'twisty_puzzles/utils/array_helper'
+require 'twisty_puzzles/native'
+
+module TwistyPuzzles
+  
+    # Represents the state (i.e. the sticker positions) of a cube.
+    class CubeState
+      include Utils::ArrayHelper
+      include CubePrintHelper
+      include StateHelper
+      include CubeConstants
+
+      def self.check_cube_size(cube_size)
+        raise TypeError unless cube_size.is_a?(Integer)
+        raise ArgumentError, 'Cubes of size smaller than 2 are not supported.' if cube_size < 2
+      end
+
+      def self.from_stickers(cube_size, stickers)
+        CubeState.check_cube_size(cube_size)
+        unless stickers.length == FACE_SYMBOLS.length
+          raise ArgumentError, "Cubes must have #{FACE_SYMBOLS.length} sides."
+        end
+
+        unless stickers.all? { |p| p.length == cube_size && p.all? { |q| q.length == cube_size } }
+          raise ArgumentError,
+                "All sides of a #{cube_size}x#{cube_size} must be #{cube_size}x#{cube_size}."
+        end
+
+        stickers_hash = create_stickers_hash(stickers)
+        new(Native::CubeState.new(cube_size, stickers_hash))
+      end
+
+      def self.create_stickers_hash(stickers)
+        FACE_SYMBOLS.zip(stickers).map do |face_symbol, face_stickers|
+          face = Face.for_face_symbol(face_symbol)
+          face_hash = {
+            stickers: face_stickers,
+            # Note that in the ruby code, x and y are exchanged s.t. one can say bla[x][y],
+            # but the C code does the more logical thing,
+            # so we have to swap coordinates here.
+            x_base_face_symbol: face.coordinate_index_base_face(1).face_symbol,
+            y_base_face_symbol: face.coordinate_index_base_face(0).face_symbol
+          }
+          [face_symbol, face_hash]
+        end.to_h
+      end
+
+      def initialize(native)
+        raise TypeError unless native.is_a?(Native::CubeState)
+
+        @native = native
+      end
+
+      def dup
+        CubeState.new(@native.dup)
+      end
+
+      attr_reader :native
+
+      def n
+        @native.cube_size
+      end
+
+      def stickers; end
+
+      def eql?(other)
+        self.class.equal?(other.class) && @native == other.native
+      end
+
+      alias == eql?
+
+      def hash
+        @hash ||= [self.class, @native].hash
+      end
+
+      # TODO: Get rid of this backwards compatibility artifact
+      def sticker_array(face)
+        raise TypeError unless face.is_a?(Face)
+
+        @native.sticker_array(
+          face.face_symbol,
+          # Note that in the ruby code, x and y are exchanged s.t. one can say bla[x][y],
+          # but the C code does the more logical thing,
+          # so we have to swap coordinates here.
+          face.coordinate_index_base_face(1).face_symbol,
+          face.coordinate_index_base_face(0).face_symbol
+        )
+      end
+
+      def to_s
+        cube_string(self, :nocolor)
+      end
+
+      def colored_to_s
+        cube_string(self, :color)
+      end
+
+      def [](coordinate)
+        @native[coordinate.native]
+      end
+
+      def []=(coordinate, color)
+        @native[coordinate.native] = color
+      end
+    end
+end

data/lib/twisty_puzzles/letter_scheme.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/cube'
+
+module TwistyPuzzles
+  # Letter scheme that maps stickers to letters.
+  class LetterScheme
+    def initialize
+      alphabet.each do |letter|
+        raise "Uncanonical letter #{letter} in alphabet." if letter != canonicalize_letter(letter)
+      end
+    end
+
+    def letter(piece)
+      alphabet[piece.piece_index]
+    end
+
+    def for_letter(part_type, desired_letter)
+      canonicalized_letter = canonicalize_letter(desired_letter)
+      part_type::ELEMENTS.find { |e| letter(e) == canonicalized_letter }
+    end
+
+    def valid_letter?(letter)
+      alphabet.include?(canonicalize_letter(letter))
+    end
+
+    def alphabet
+      raise NotImplementedError
+    end
+
+    def canonicalize_letter(_letter)
+      raise NotImplementedError
+    end
+
+    def parse_part(part_type, part_string)
+      if valid_letter?(part_string)
+        for_letter(part_type, part_string)
+      else
+        part_type.parse(part_string)
+      end
+    end
+
+    alias parse_buffer parse_part
+  end
+
+  # Letter scheme used by Bernhard Brodowsky.
+  class BernhardLetterScheme < LetterScheme
+    PART_TYPE_BUFFERS = {
+      Corner => Corner.for_face_symbols(%i[U L B]),
+      Edge => Edge.for_face_symbols(%i[U F]),
+      Wing => Wing.for_face_symbols(%i[F U]),
+      XCenter => XCenter.for_face_symbols(%i[U R F]),
+      TCenter => TCenter.for_face_symbols(%i[U F])
+    }.freeze
+    def alphabet
+      @alphabet ||= 'a'.upto('x').to_a
+    end
+
+    def canonicalize_letter(letter)
+      letter.downcase
+    end
+
+    # Letters that we shoot to by default.
+    def shoot_letters(_part_type)
+      %w[a b d l h t p]
+    end
+
+    def default_buffer(part_type)
+      PART_TYPE_BUFFERS[part_type]
+    end
+  end
+end