twisty_puzzles 0.0.1

data/lib/twisty_puzzles/skewb_direction.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/abstract_direction'
+
+module TwistyPuzzles
+  
+    # Represents the direction of a Skewb move except a rotation.
+    class SkewbDirection < AbstractDirection
+      NUM_DIRECTIONS = 3
+      NON_ZERO_DIRECTIONS = (1...NUM_DIRECTIONS).map { |d| new(d) }.freeze
+      ALL_DIRECTIONS = Array.new(NUM_DIRECTIONS) { |d| new(d) }.freeze
+      ZERO = new(0)
+      FORWARD = new(1)
+      BACKWARD = new(2)
+
+      def name
+        SIMPLE_SKEWB_DIRECTION_NAMES[@value]
+      end
+
+      def double_move?
+        false
+      end
+    end
+end

data/lib/twisty_puzzles/skewb_move.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/abstract_move'
+require 'twisty_puzzles/cube'
+require 'twisty_puzzles/skewb_direction'
+require 'twisty_puzzles/puzzle'
+
+module TwistyPuzzles
+  
+    # Base class for skewb moves.
+    class SkewbMove < AbstractMove
+      def initialize(axis_corner, direction)
+        raise TypeError unless axis_corner.is_a?(Corner)
+        raise TypeError unless direction.is_a?(SkewbDirection)
+
+        @axis_corner = axis_corner.rotate_face_up(axis_corner.faces.min_by(&:piece_index))
+        @direction = direction
+      end
+
+      def puzzles
+        [Puzzle::SKEWB]
+      end
+
+      attr_reader :axis_corner, :direction
+
+      def to_s
+        "#{@axis_corner}#{@direction.name}"
+      end
+
+      def slice_move?
+        false
+      end
+
+      def identifying_fields
+        [@axis_corner, @direction]
+      end
+
+      def rotate_by(rotation)
+        nice_face =
+          find_only(@axis_corner.adjacent_faces) do |f|
+            f.same_axis?(rotation.axis_face)
+          end
+        nice_direction = rotation.translated_direction(nice_face)
+        nice_face_corners = nice_face.clockwise_corners
+        on_nice_face_index = nice_face_corners.index { |c| c.turned_equals?(@axis_corner) }
+        new_corner =
+          nice_face_corners[(on_nice_face_index + nice_direction.value) % nice_face_corners.length]
+        self.class.new(new_corner, @direction)
+      end
+
+      def mirror(normal_face)
+        faces = @axis_corner.adjacent_faces
+        replaced_face = find_only(faces) { |f| f.same_axis?(normal_face) }
+        new_corner =
+          Corner.between_faces(replace_once(faces, replaced_face, replaced_face.opposite))
+        self.class.new(new_corner, @direction.inverse)
+      end
+    end
+end

data/lib/twisty_puzzles/skewb_move_parser.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/abstract_direction'
+require 'twisty_puzzles/abstract_move_parser'
+require 'twisty_puzzles/move_type_creator'
+require 'twisty_puzzles/rotation'
+require 'twisty_puzzles/skewb_move'
+require 'twisty_puzzles/skewb_notation'
+
+module TwistyPuzzles
+  
+    # Parser for Skewb moves.
+    class SkewbMoveParser < AbstractMoveParser
+      MOVE_TYPE_CREATORS = [
+        MoveTypeCreator.new(%i[axis_face cube_direction], Rotation),
+        MoveTypeCreator.new(%i[axis_corner skewb_direction], SkewbMove)
+      ].freeze
+
+      def initialize(notation)
+        raise TypeError unless notation.is_a?(SkewbNotation)
+
+        @notation = notation
+      end
+
+      FIXED_CORNER_INSTANCE = SkewbMoveParser.new(SkewbNotation.fixed_corner)
+      SARAH_INSTANCE = SkewbMoveParser.new(SkewbNotation.sarah)
+      RUBIKS_INSTANCE = SkewbMoveParser.new(SkewbNotation.rubiks)
+
+      def regexp
+        @regexp ||=
+          begin
+            skewb_direction_names =
+              AbstractDirection::POSSIBLE_SKEWB_DIRECTION_NAMES.flatten
+            move_part = "(?:(?<skewb_move>[#{@notation.move_strings.join}])" \
+                        "(?<skewb_direction>[#{skewb_direction_names.join}]?))"
+            rotation_direction_names =
+              AbstractDirection::POSSIBLE_DIRECTION_NAMES.flatten
+            rotation_direction_names.sort_by! { |e| -e.length }
+            rotation_part = "(?:(?<axis_name>[#{AbstractMove::AXES.join}])" \
+                            "(?<cube_direction>#{rotation_direction_names.join('|')}))"
+            Regexp.new("#{move_part}|#{rotation_part}")
+          end
+      end
+
+      def move_type_creators
+        MOVE_TYPE_CREATORS
+      end
+
+      def parse_skewb_direction(direction_string)
+        if AbstractDirection::POSSIBLE_DIRECTION_NAMES[0].include?(direction_string)
+          SkewbDirection::FORWARD
+        elsif AbstractDirection::POSSIBLE_DIRECTION_NAMES[-1].include?(direction_string)
+          SkewbDirection::BACKWARD
+        else
+          raise ArgumentError
+        end
+      end
+
+      def parse_part_key(name)
+        name.sub('name', 'face').sub('skewb_move', 'axis_corner')
+      end
+
+      def parse_move_part(name, value)
+        case name
+        when 'axis_name' then CubeMoveParser::INSTANCE.parse_axis_face(value)
+        when 'cube_direction' then CubeMoveParser::INSTANCE.parse_direction(value)
+        when 'skewb_move' then @notation.corner(value)
+        when 'skewb_direction' then parse_skewb_direction(value)
+        else raise
+        end
+      end
+    end
+end

data/lib/twisty_puzzles/skewb_notation.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/cancellation_helper'
+require 'twisty_puzzles/cube'
+require 'twisty_puzzles/cube_direction'
+require 'twisty_puzzles/skewb_direction'
+require 'twisty_puzzles/skewb_move'
+
+module TwistyPuzzles
+  
+    # Class that represents one notation for Skewb moves, e.g. Sarahs notation or fixed
+    # corner notation.
+    class SkewbNotation
+      def initialize(name, move_corner_pairs)
+        raise TypeError unless name.is_a?(String)
+
+        check_move_corner_pairs(move_corner_pairs)
+        @name = name
+        @move_to_corner = move_corner_pairs.to_h.freeze
+        @corner_to_move = move_corner_pairs.collect_concat do |m, c|
+          c.rotations.map { |e| [e, m] }
+        end.to_h.freeze
+        @move_strings = move_corner_pairs.map(&:first).freeze
+        @non_zero_moves =
+          move_corner_pairs.map(&:last).product(SkewbDirection::NON_ZERO_DIRECTIONS).map do |c, d|
+            SkewbMove.new(c, d)
+          end.freeze
+        freeze
+      end
+
+      def check_move_corner_pairs(move_corner_pairs)
+        move_corner_pairs.each do |m|
+          raise ArgumentError unless m.length == 2
+          raise TypeError unless m[0].is_a?(String)
+          raise TypeError unless m[1].is_a?(Corner)
+        end
+        if move_corner_pairs.map(&:first).uniq.length != move_corner_pairs.length
+          raise ArgumentError
+        end
+
+        check_corner_coverage(move_corner_pairs.map(&:last))
+      end
+
+      def check_corner_coverage(corners)
+        corner_closure = corners + corners.map(&:diagonal_opposite)
+        Corner::ELEMENTS.each do |corner|
+          unless corner_closure.any? { |c| c.turned_equals?(corner) }
+            raise ArgumentError,
+                  "Turns around corner #{corner} cannot be represented in notation #{name}."
+          end
+        end
+      end
+
+      attr_reader :name, :move_strings, :non_zero_moves
+      private_class_method :new
+
+      def self.fixed_corner
+        @fixed_corner ||= new(
+          'fixed corner', [
+            ['U', Corner.for_face_symbols(%i[U L B])],
+            ['R', Corner.for_face_symbols(%i[D R B])],
+            ['L', Corner.for_face_symbols(%i[D F L])],
+            ['B', Corner.for_face_symbols(%i[D B L])]
+          ]
+        )
+      end
+
+      def self.sarah
+        @sarah ||= new(
+          'sarah', [
+            ['F', Corner.for_face_symbols(%i[U R F])],
+            ['R', Corner.for_face_symbols(%i[U B R])],
+            ['B', Corner.for_face_symbols(%i[U L B])],
+            ['L', Corner.for_face_symbols(%i[U F L])]
+          ]
+        )
+      end
+
+      def self.rubiks
+        @rubiks ||= new(
+          'rubiks', [
+            ['F', Corner.for_face_symbols(%i[U R F])],
+            ['R', Corner.for_face_symbols(%i[U B R])],
+            ['B', Corner.for_face_symbols(%i[U L B])],
+            ['L', Corner.for_face_symbols(%i[U F L])],
+            ['f', Corner.for_face_symbols(%i[D F R])],
+            ['r', Corner.for_face_symbols(%i[D R B])],
+            ['b', Corner.for_face_symbols(%i[D B L])],
+            ['l', Corner.for_face_symbols(%i[D L F])]
+          ]
+        )
+      end
+
+      def to_s
+        @name
+      end
+
+      def corner(move)
+        @move_to_corner[move] || (raise ArgumentError)
+      end
+
+      def algorithm_to_string(algorithm)
+        reversed_rotations = []
+        num_tail_rotations = CancellationHelper.num_tail_rotations(algorithm)
+        alg_string = algorithm.moves[0...algorithm.length - num_tail_rotations].map do |m|
+          move_to_string(m, reversed_rotations)
+        end.join(' ')
+        new_tail_rotations = reversed_rotations.reverse! +
+                             algorithm.moves[algorithm.length - num_tail_rotations..-1]
+        cancelled_rotations = Algorithm.new(new_tail_rotations).cancelled(3)
+        cancelled_rotations.empty? ? alg_string : "#{alg_string} #{cancelled_rotations}"
+      end
+
+      private
+
+      def move_to_string(move, reversed_rotations)
+        reversed_rotations.each { |r| move = move.rotate_by(r.inverse) }
+        case move
+        when SkewbMove then skewb_move_to_string(move, reversed_rotations)
+        when Rotation then move.to_s
+        else raise ArgumentError, "Couldn't transform #{move} to #{@name} Skewb notation."
+        end
+      end
+
+      def skewb_move_to_string(move, reversed_rotations)
+        move_string, rotate = move_to_string_internal(move)
+        if rotate
+          reversed_additional_rotations =
+            Rotation.around_corner(move.axis_corner, move.direction).moves.reverse
+          reversed_rotations.concat(reversed_additional_rotations)
+        end
+        "#{move_string}#{move.direction.name}"
+      end
+
+      # Returns the move string of the given move and true if a rotation has to be done to correct
+      # for the fact that we actually used the opposite corner.
+      def move_to_string_internal(move)
+        if (move_string = @corner_to_move[move.axis_corner])
+          [move_string, false]
+        elsif (move_string = @corner_to_move[move.axis_corner.diagonal_opposite])
+          [move_string, !move.direction.zero?]
+        else
+          raise
+        end
+      end
+    end
+end

data/lib/twisty_puzzles/skewb_state.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/coordinate'
+require 'twisty_puzzles/cube'
+require 'twisty_puzzles/cube_print_helper'
+require 'twisty_puzzles/state_helper'
+require 'twisty_puzzles/cube_constants'
+
+module TwistyPuzzles
+  
+    # Represents the state (i.e. the sticker positions) of a Skewb.
+    class SkewbState
+      include CubePrintHelper
+      include StateHelper
+      include CubeConstants
+      # Pairs of coordinate pairs that should match in case of solved layers.
+      MATCHING_CORNERS =
+        begin
+          matching_corners = []
+          Corner::ELEMENTS.each do |c1|
+            Corner::ELEMENTS.each do |c2|
+              # Take corner pairs that have a common edge.
+              next unless c1.common_edge_with?(c2)
+
+              check_parts = []
+              c1.rotations.each do |c1_rot|
+                next unless c2.face_symbols.include?(c1_rot.face_symbols.first)
+
+                c2_rot = c2.rotate_face_symbol_up(c1_rot.face_symbols.first)
+                check_parts.push([
+                                   SkewbCoordinate.for_corner(c1_rot),
+                                   SkewbCoordinate.for_corner(c2_rot)
+                                 ])
+              end
+              matching_corners.push(check_parts)
+            end
+          end
+          matching_corners.uniq
+        end
+      # Pairs of stickers that can be used to check whether the "outside" of a layer on the given
+      # face is a proper layer.
+      LAYER_CHECK_NEIGHBORS =
+        begin
+          layer_check_neighbors = {}
+          MATCHING_CORNERS.each do |a, b|
+            [[a.first.face, b], [b.first.face, a]].each do |face, coordinates|
+              # We take the first one we encounter, but it doesn't matter, we could take any.
+              layer_check_neighbors[face] ||= coordinates
+            end
+          end
+          layer_check_neighbors
+        end
+
+      def initialize(native)
+        raise TypeError unless native.is_a?(Native::SkewbState)
+
+        @native = native
+      end
+
+      attr_reader :native
+
+      def self.for_solved_colors(solved_colors)
+        native = Native::SkewbState.new(solved_colors)
+        new(native)
+      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)
+
+        center_sticker = self[SkewbCoordinate.for_center(face)]
+        corner_stickers =
+          face.clockwise_corners.sort.map do |c|
+            self[SkewbCoordinate.for_corner(c)]
+          end
+        [center_sticker] + corner_stickers
+      end
+
+      def dup
+        SkewbState.new(@native.dup)
+      end
+
+      def to_s
+        skewb_string(self, :nocolor)
+      end
+
+      def colored_to_s
+        skewb_string(self, :color)
+      end
+
+      def apply_move(move)
+        move.apply_to(self)
+      end
+
+      def apply_algorithm(alg)
+        alg.apply_to(self)
+      end
+
+      def apply_rotation(rot)
+        rot.apply_to_skewb(self)
+      end
+
+      def [](coordinate)
+        @native[coordinate.native]
+      end
+
+      def []=(coordinate, color)
+        @native[coordinate.native] = color
+        sticker_array(coordinate.face)[coordinate.coordinate] = color
+      end
+
+      def any_layer_solved?
+        !solved_layers.empty?
+      end
+
+      # Returns the color of all solved layers. Empty if there is none.
+      def solved_layers
+        solved_faces = Face::ELEMENTS.select { |f| layer_at_face_solved?(f) }
+        solved_faces.map { |f| self[SkewbCoordinate.for_center(f)] }
+      end
+
+      def layer_solved?(color)
+        Face::ELEMENTS.any? do |f|
+          self[SkewbCoordinate.for_center(f)] == color && layer_at_face_solved?(f)
+        end
+      end
+
+      def center_face(color)
+        Face::ELEMENTS.find { |f| self[SkewbCoordinate.for_center(f)] == color }
+      end
+
+      def layer_check_neighbors(face)
+        LAYER_CHECK_NEIGHBORS[face]
+      end
+
+      # Note that this does NOT say that the layer corresponding to the given face is solved.
+      # The face argument is used as the position where a solved face is present.
+      def layer_at_face_solved?(face)
+        return false unless native.face_solved?(face.face_symbol)
+
+        layer_check_neighbors(face).map { |c| self[c] }.uniq.length == 1
+      end
+
+      def rotate_face(face, direction)
+        neighbors = face.neighbors
+        inverse_order_face = face.coordinate_index_close_to(neighbors[0]) <
+                             face.coordinate_index_close_to(neighbors[1])
+        direction = direction.inverse if inverse_order_face
+        cycle = SkewbCoordinate.corners_on_face(face)
+        apply_4sticker_cycle(cycle, direction)
+      end
+    end
+end