twisty_puzzles 0.0.1

data/lib/twisty_puzzles/algorithm_transformation.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/cube_direction'
+require 'twisty_puzzles/rotation'
+
+module TwistyPuzzles
+  
+    AlgorithmTransformation =
+      Struct.new(:rotation, :mirror, :mirror_normal_face) do
+        def transformed(algorithm)
+          algorithm = algorithm.mirror(mirror_normal_face) if mirror
+          algorithm.rotate_by(rotation)
+        end
+
+        def identity?
+          rotation.identity? && !mirror
+        end
+
+        # Returns algorithm transformations that mirror an algorithm and rotate it around a face.
+        def self.around_face(face)
+          around_face_rotations = CubeDirection::ALL_DIRECTIONS.map { |d| Rotation.new(face, d) }
+          mirror_normal_face = face.neighbors.first
+          around_face_rotations.product([true, false]).map do |r, m|
+            AlgorithmTransformation.new(r, m, mirror_normal_face)
+          end
+        end
+
+        def self.around_face_without_identity(face)
+          around_face(face).reject(&:identity?)
+        end
+      end
+  end
+end

data/lib/twisty_puzzles/axis_face_and_direction_move.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/abstract_move'
+require 'twisty_puzzles/cube_direction'
+
+module TwistyPuzzles
+  
+    # Intermediate base class for all types of moves that have an axis face and a direction,
+    # i.e. cube moves and rotations.
+    class AxisFaceAndDirectionMove < AbstractMove
+      def initialize(axis_face, direction)
+        raise TypeError, "Unsuitable axis face #{axis_face}." unless axis_face.is_a?(Face)
+        raise TypeError unless direction.is_a?(CubeDirection)
+
+        @axis_face = axis_face
+        @direction = direction
+      end
+
+      attr_reader :direction, :axis_face
+
+      def translated_direction(other_axis_face)
+        case @axis_face
+        when other_axis_face then @direction
+        when other_axis_face.opposite then @direction.inverse
+        else raise ArgumentError
+        end
+      end
+
+      def same_axis?(other)
+        @axis_face.same_axis?(other.axis_face)
+      end
+
+      def identifying_fields
+        [@axis_face, @direction]
+      end
+
+      def canonical_direction
+        @axis_face.canonical_axis_face? ? @direction : @direction.inverse
+      end
+
+      def can_swap?(other)
+        super || same_axis?(other)
+      end
+
+      def swap_internal(other)
+        if same_axis?(other)
+          [other, self]
+        else
+          super
+        end
+      end
+
+      def rotate_by(rotation)
+        if same_axis?(rotation)
+          self
+        else
+          rotation_neighbors = rotation.axis_face.neighbors
+          face_index = rotation_neighbors.index(@axis_face) || raise
+          new_axis_face =
+            rotation_neighbors[(face_index + rotation.direction.value) % rotation_neighbors.length]
+          fields = replace_once(identifying_fields, @axis_face, new_axis_face)
+          self.class.new(*fields)
+        end
+      end
+
+      def mirror(normal_face)
+        if normal_face.same_axis?(@axis_face)
+          fields = replace_once(
+            replace_once(identifying_fields, @direction, @direction.inverse),
+            @axis_face, @axis_face.opposite
+          )
+          self.class.new(*fields)
+        else
+          inverse
+        end
+      end
+    end
+end

data/lib/twisty_puzzles/cancellation_helper.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/abstract_move'
+require 'twisty_puzzles/algorithm'
+require 'twisty_puzzles/cube_constants'
+require 'twisty_puzzles/cube_state'
+
+module TwistyPuzzles
+  
+    # Helper class to figure out information about the cancellation between two algs.
+    module CancellationHelper
+      include CubeConstants
+
+      def self.swap_to_end(algorithm, index)
+        new_moves = algorithm.moves.dup
+        index.upto(algorithm.length - 2) do |current_index|
+          obstacle_index = current_index + 1
+          current = new_moves[current_index]
+          obstacle = new_moves[obstacle_index]
+          return nil unless current.can_swap?(obstacle)
+
+          new_moves[current_index], new_moves[obstacle_index] = current.swap(obstacle)
+        end
+        Algorithm.new(new_moves)
+      end
+
+      # Possible variations of the algorithm where the last move has been swapped as much as allowed
+      # (e.g. D U can swap).
+      def self.cancel_variants(algorithm)
+        variants = []
+        algorithm.moves.each_index.reverse_each do |i|
+          variant = swap_to_end(algorithm, i)
+          break unless variant
+
+          variants.push(variant)
+        end
+        raise if variants.empty?
+
+        variants
+      end
+
+      # Cancel this algorithm as much as possilbe
+      def self.cancel(algorithm, cube_size)
+        raise TypeError unless algorithm.is_a?(Algorithm)
+
+        CubeState.check_cube_size(cube_size)
+        alg = Algorithm::EMPTY
+        algorithm.moves.each do |m|
+          alg = push_with_cancellation(alg, m, cube_size)
+        end
+        alg
+      end
+
+      def self.combine_transformations(left, right)
+        left.dup.transform_values { |e| right[e] }.freeze
+      end
+
+      def self.apply_transformation_to!(transformation, face_state)
+        face_state.map! { |f| transformation[f] }
+      end
+
+      TRIVIAL_CENTER_TRANSFORMATION = { U: :U, F: :F, R: :R, L: :L, B: :B, D: :D }.freeze
+
+      def self.create_directed_transformations(basic_transformation, invert)
+        twice = combine_transformations(basic_transformation, basic_transformation)
+        thrice = combine_transformations(twice, basic_transformation)
+        non_zero_transformations = [basic_transformation, twice, thrice]
+        adjusted_non_zero_transformations =
+          invert ? non_zero_transformations.reverse : non_zero_transformations
+        [TRIVIAL_CENTER_TRANSFORMATION] + adjusted_non_zero_transformations
+      end
+
+      CENTER_TRANSFORMATIONS =
+        begin
+          x_transformation = { U: :B, F: :U, R: :R, L: :L, B: :D, D: :F }.freeze
+          y_transformation = { U: :U, F: :L, R: :F, L: :B, B: :R, D: :D }.freeze
+          z_transformation = { U: :R, F: :F, R: :D, L: :U, B: :B, D: :L }.freeze
+          {
+            U: create_directed_transformations(y_transformation, false),
+            F: create_directed_transformations(z_transformation, false),
+            R: create_directed_transformations(x_transformation, false),
+            L: create_directed_transformations(x_transformation, true),
+            B: create_directed_transformations(z_transformation, true),
+            D: create_directed_transformations(y_transformation, true)
+          }
+        end
+
+      def self.center_transformation(rotation)
+        CENTER_TRANSFORMATIONS[rotation.axis_face.face_symbol][rotation.direction.value]
+      end
+
+      def self.rotated_center_state(rotations)
+        rotations.reduce(FACE_SYMBOLS.dup) do |center_state, rotation|
+          apply_transformation_to!(center_transformation(rotation), center_state)
+        end
+      end
+
+      def self.combined_rotation_algs
+        Rotation::NON_ZERO_ROTATIONS.collect_concat do |left|
+          second_rotations =
+            Rotation::NON_ZERO_ROTATIONS.reject do |e|
+              e.direction.double_move? || e.same_axis?(left)
+            end
+          second_rotations.map { |right| Algorithm.new([left, right]) }
+        end
+      end
+
+      def self.rotation_sequences
+        @rotation_sequences ||=
+          begin
+            trivial_rotation_algs = [Algorithm::EMPTY]
+            single_rotation_algs = Rotation::NON_ZERO_ROTATIONS.map { |e| Algorithm.move(e) }
+            combined_rotation_algs = self.combined_rotation_algs
+            rotation_algs = trivial_rotation_algs + single_rotation_algs + combined_rotation_algs
+            rotation_algs.map do |alg|
+              [rotated_center_state(alg.moves), alg]
+            end.to_h.freeze
+          end
+      end
+
+      def self.cancelled_rotations(rotations)
+        center_state = rotated_center_state(rotations)
+        rotation_sequences[center_state]
+      end
+
+      def self.num_tail_rotations(algorithm)
+        num = 0
+        algorithm.moves.reverse_each do |e|
+          break unless e.is_a?(Rotation)
+
+          num += 1
+        end
+        num
+      end
+
+      def self.alg_plus_cancelled_move(algorithm, move, cube_size)
+        if move.is_a?(Rotation) && (tail_rotations = num_tail_rotations(algorithm)) >= 2
+          Algorithm.new(algorithm.moves[0...-tail_rotations]) +
+            cancelled_rotations(algorithm.moves[-tail_rotations..-1] + [move])
+        else
+          Algorithm.new(algorithm.moves[0...-1]) +
+            algorithm.moves[-1].join_with_cancellation(move, cube_size)
+        end
+      end
+
+      def self.push_with_cancellation(algorithm, move, cube_size)
+        raise TypeError unless move.is_a?(AbstractMove)
+        return Algorithm.move(move) if algorithm.empty?
+
+        cancel_variants =
+          cancel_variants(algorithm).map do |alg|
+            alg_plus_cancelled_move(alg, move, cube_size)
+          end
+        cancel_variants.min_by do |alg|
+          # QTM is the most sensitive metric, so we use that as the highest priority for
+          # cancellations.
+          # We use HTM as a second priority to make sure something like RR still gets merged into
+          # R2.
+          # We use the length as tertiary priority to make sure rotations get cancelled even if they
+          # don't change the move count.
+          [alg.move_count(cube_size, :qtm), alg.move_count(cube_size, :htm), alg.length]
+        end
+      end
+    end
+end

data/lib/twisty_puzzles/color_scheme.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/cube'
+require 'twisty_puzzles/cube_constants'
+require 'twisty_puzzles/cube_state'
+require 'twisty_puzzles/skewb_state'
+require 'twisty_puzzles/utils/array_helper'
+
+module TwistyPuzzles
+  # A color scheme that assigns a color to each face.
+  class ColorScheme
+    include CubeConstants
+    include Utils::ArrayHelper
+
+    RESERVED_COLORS = %i[transparent unknown oriented].freeze
+
+    def initialize(face_symbols_to_colors)
+      check_face_symbols_to_colors(face_symbols_to_colors)
+
+      num_uniq_colors = face_symbols_to_colors.values.uniq.length
+      unless num_uniq_colors == FACE_SYMBOLS.length
+        raise ArgumentError, "Got #{num_uniq_colors} unique colors " \
+                             "#{face_symbols_to_colors.values.uniq}, " \
+                             "but needed #{FACE_SYMBOLS.length}."
+      end
+
+      @face_symbols_to_colors = face_symbols_to_colors
+      @colors_to_face_symbols = face_symbols_to_colors.invert
+    end
+
+    def color(face_symbol)
+      @face_symbols_to_colors[face_symbol]
+    end
+
+    def opposite_color(color)
+      color(opposite_face_symbol(face_symbol(color)))
+    end
+
+    def part_for_colors(part_type, colors)
+      raise ArgumentError unless part_type.is_a?(Class)
+
+      part_type.for_face_symbols(colors.map { |c| face_symbol(c) })
+    end
+
+    def face_symbol(color)
+      @colors_to_face_symbols[color]
+    end
+
+    def colors
+      @face_symbols_to_colors.values
+    end
+
+    def turned(top_color, front_color)
+      raise ArgumentError if top_color == front_color
+      raise ArgumentError if opposite_color(top_color) == front_color
+      raise ArgumentError unless colors.include?(top_color)
+      raise ArgumentError unless colors.include?(front_color)
+
+      # Note: The reason that this is so complicated is that we want it to still work if the
+      # chirality corner gets exchanged.
+
+      # Do the obvious and handle opposites of the top and front color so we have no
+      # assumptions that the chirality corner contains U and F.
+      turned_face_symbols_to_colors =
+        obvious_turned_face_symbols_to_colors(top_color, front_color)
+
+      # Now find the corner that gets mapped to the chirality corner. We know
+      # two of its colors and the position of the missing color.
+      chirality_corner_source, unknown_index =
+        chirality_corner_source_and_unknown_index(turned_face_symbols_to_colors)
+
+      add_missing_mappings(turned_face_symbols_to_colors, chirality_corner_source, unknown_index)
+
+      ColorScheme.new(turned_face_symbols_to_colors)
+    end
+
+    def solved_cube_state(cube_size)
+      stickers =
+        ordered_colors.map do |c|
+          Array.new(cube_size) { Array.new(cube_size) { c } }
+        end
+      CubeState.from_stickers(cube_size, stickers)
+    end
+
+    # Colors in the order of the face symbols.
+    def ordered_colors
+      FACE_SYMBOLS.map { |s| color(s) }
+    end
+
+    def solved_skewb_state
+      SkewbState.for_solved_colors(@face_symbols_to_colors.dup)
+    end
+
+    private
+
+    def chirality_corner_source_and_unknown_index(obvious_turned_face_symbols_to_colors)
+      corner_matcher =
+        CornerMatcher.new(CHIRALITY_FACE_SYMBOLS.map do |s|
+                            # This will return nil for exactly one face that we don't know yet.
+                            @colors_to_face_symbols[obvious_turned_face_symbols_to_colors[s]]
+                          end)
+
+      # There should be exactly one corner that gets mapped to the chirality corner.
+      chirality_corner_source =
+        find_only(Corner::ELEMENTS) do |corner|
+          corner_matcher.matches?(corner)
+        end
+      [chirality_corner_source, corner_matcher.wildcard_index]
+    end
+
+    # Corner matcher that finds a corner that has one arbitrary
+    # face symbol and two given face symbol.
+    class CornerMatcher
+      def initialize(face_symbol_matchers)
+        unless face_symbol_matchers.count(&:nil?) == 1
+          raise ArgumentError, 'Exactly one nil allowed in face symbol matchers.'
+        end
+
+        @face_symbol_matchers = face_symbol_matchers
+      end
+
+      def matches?(corner)
+        corner.face_symbols.zip(@face_symbol_matchers).all? do |face_symbol, face_symbol_matcher|
+          face_symbol_matcher.nil? || face_symbol == face_symbol_matcher
+        end
+      end
+
+      def wildcard_index
+        @face_symbol_matchers.index(nil)
+      end
+    end
+
+    def check_face_symbols_to_colors(face_symbols_to_colors)
+      raise ArgumentError unless face_symbols_to_colors.keys.sort == FACE_SYMBOLS.sort
+
+      face_symbols_to_colors.each_value do |c|
+        raise TypeError unless c.is_a?(Symbol)
+
+        if RESERVED_COLORS.include?(c)
+          raise ArgumentError,
+                "Color #{c} cannot be part of the color scheme because it is a reserved color."
+        end
+      end
+      raise ArgumentError unless face_symbols_to_colors.values.all? { |c| c.is_a?(Symbol) }
+    end
+
+    def add_missing_mappings(turned_face_symbols_to_colors, chirality_corner_source, unknown_index)
+      missing_face_symbol = CHIRALITY_FACE_SYMBOLS[unknown_index]
+      missing_face_symbol_source =
+        chirality_corner_source.face_symbols[unknown_index]
+      turned_face_symbols_to_colors[missing_face_symbol] = color(missing_face_symbol_source)
+      turned_face_symbols_to_colors[opposite_face_symbol(missing_face_symbol)] =
+        color(opposite_face_symbol(missing_face_symbol_source))
+    end
+
+    def obvious_turned_face_symbols_to_colors(top_color, front_color)
+      result = { U: top_color, F: front_color }
+      opposites = result.map do |face_symbol, color|
+        [opposite_face_symbol(face_symbol), opposite_color(color)]
+      end.to_h
+      result.merge!(opposites)
+    end
+
+    WCA = new(
+      U: :white,
+      F: :green,
+      R: :red,
+      L: :orange,
+      B: :blue,
+      D: :yellow
+    ).freeze
+    BERNHARD = WCA.turned(:yellow, :red).freeze
+  end
+end