twisty_puzzles 0.0.2 → 0.0.3

data/ext/twisty_puzzles/native/cube_state.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <ruby.h>
+
+#include "face_symbols.h"
+
+typedef struct {
+  size_t cube_size;
+  VALUE* stickers;
+} CubeStateData;
+
+extern const rb_data_type_t CubeStateData_type;
+
+#define GetCubeStateData(obj, data) \
+  do { \
+    TypedData_Get_Struct((obj), CubeStateData, &CubeStateData_type, (data)); \
+  } while (0)
+
+#define GetInitializedCubeStateData(obj, data)  \
+  do { \
+    GetCubeStateData((obj), (data)); \
+    if (data->stickers == NULL) { \
+      rb_raise(rb_eArgError, "Cube state isn't initialized."); \
+    } \
+  } while(0)
+
+void rotate_slice_for_cube(face_index_t turned_face_index, size_t slice_index, direction_t direction, const CubeStateData* data);
+
+void rotate_face_for_cube(face_index_t turned_face_index, direction_t direction, const CubeStateData* data);
+
+void init_cube_state_class_under(VALUE module);

data/ext/twisty_puzzles/native/face_symbols.c

@@ -0,0 +1,67 @@
+#include "face_symbols.h"
+
+#include <stdlib.h>
+
+static ID face_ids[cube_faces];
+
+face_index_t face_index(const VALUE face_symbol) {
+  Check_Type(face_symbol, T_SYMBOL);
+  const ID face_id = SYM2ID(face_symbol);
+  for (size_t i = 0; i < cube_faces; ++i) {
+    if (face_ids[i] == face_id) {
+      return i;
+    }
+  }
+  rb_raise(rb_eArgError, "Invalid face symbol %+"PRIsVALUE"", face_symbol);
+}
+
+// TODO This is very unelegant.
+static const face_index_t U_neighbors[neighbor_faces] = {F, L, B, R};
+static const face_index_t F_neighbors[neighbor_faces] = {U, R, D, L};
+static const face_index_t R_neighbors[neighbor_faces] = {U, B, D, F};
+
+face_index_t neighbor_face_index(const face_index_t face_index, const size_t index) {
+  const size_t adjusted_index = face_index == axis_index(face_index) ? index : -index;
+  const size_t cropped_index = (adjusted_index % 4 + 4) % 4;
+  switch (axis_index(face_index)) {
+  case U: return U_neighbors[cropped_index];
+  case F: return F_neighbors[cropped_index];
+  case R: return R_neighbors[cropped_index];
+  default:
+    rb_raise(rb_eRuntimeError, "invalid axis index");
+  }
+}
+
+VALUE face_symbol(const face_index_t face_index) {
+  return ID2SYM(face_ids[face_index]);
+}
+
+axis_index_t axis_index(const face_index_t face_index) {
+  return MIN(face_index, opposite_face_index(face_index));
+}
+
+bool same_axis(const face_index_t left_face_index, const face_index_t right_face_index) {
+  return axis_index(left_face_index) == axis_index(right_face_index);
+}
+
+face_index_t opposite_face_index(const face_index_t face_index) {
+  return cube_faces - 1 - face_index;
+}
+
+size_t neighbor_index(const face_index_t base_face_index, const face_index_t other_face_index) {
+  for (int i = 0; i < 4; ++i) {
+    if (neighbor_face_index(base_face_index, i) == other_face_index) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+void init_face_symbols() {
+  face_ids[U] = rb_intern("U");
+  face_ids[F] = rb_intern("F");
+  face_ids[R] = rb_intern("R");
+  face_ids[L] = rb_intern("L");
+  face_ids[B] = rb_intern("B");
+  face_ids[D] = rb_intern("D");
+}

data/ext/twisty_puzzles/native/face_symbols.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <ruby.h>
+
+#include "utils.h"
+
+typedef char face_index_t;
+typedef char axis_index_t;
+
+#define cube_faces 6
+#define neighbor_faces 4
+
+#define U 0
+#define F 1
+#define R 2
+#define L 3
+#define B 4
+#define D 5
+
+face_index_t face_index(VALUE face_symbol);
+
+face_index_t neighbor_face_index(face_index_t face_index, size_t index);
+
+VALUE face_symbol(face_index_t face_index);
+
+axis_index_t axis_index(face_index_t face_index);
+
+bool same_axis(face_index_t left_face_index, face_index_t right_face_index);
+
+face_index_t opposite_face_index(face_index_t face_index);
+
+size_t neighbor_index(face_index_t base_face_index, face_index_t other_face_index);
+
+void init_face_symbols();

data/ext/twisty_puzzles/native/native.c

@@ -0,0 +1,28 @@
+#include <ruby.h>
+
+#include "cube_algorithm.h"
+#include "cube_average.h"
+#include "cube_coordinate.h"
+#include "cube_state.h"
+#include "face_symbols.h"
+#include "skewb_algorithm.h"
+#include "skewb_coordinate.h"
+#include "skewb_layer_fingerprint.h"
+#include "skewb_state.h"
+
+VALUE TwistyPuzzlesModule = Qnil;
+VALUE NativeModule = Qnil;
+
+void Init_native() {
+  TwistyPuzzlesModule = rb_define_module("TwistyPuzzles");
+  NativeModule = rb_define_module_under(TwistyPuzzlesModule, "Native");
+  init_cube_algorithm_class_under(NativeModule);
+  init_cube_average_class_under(NativeModule);
+  init_cube_coordinate_class_under(NativeModule);
+  init_cube_state_class_under(NativeModule);
+  init_face_symbols();
+  init_skewb_algorithm_class_under(NativeModule);
+  init_skewb_coordinate_class_under(NativeModule);
+  init_skewb_layer_fingerprint_method_under(NativeModule);
+  init_skewb_state_class_under(NativeModule);
+}

data/ext/twisty_puzzles/native/skewb_algorithm.c

@@ -0,0 +1,331 @@
+#include "skewb_algorithm.h"
+
+#include "face_symbols.h"
+#include "skewb_coordinate.h"
+#include "skewb_state.h"
+#include "utils.h"
+
+static ID move_id;
+static ID rotation_id;
+static VALUE SkewbAlgorithmClass = Qnil;
+
+typedef enum {
+  MOVE,
+  ROTATION,
+} SkewbMoveType;
+
+typedef union {
+  Corner corner;
+  face_index_t face_index;
+} SkewbAxis;
+
+typedef struct {
+  SkewbMoveType type;
+  SkewbAxis axis;
+  direction_t direction;
+} SkewbMove;
+
+typedef struct {
+  size_t size;
+  // We need this because we can't use the usual checking for 0/NULL because and empty algorithm is valid.
+  bool initialized;
+  SkewbMove* moves;
+} SkewbAlgorithmData;
+
+static void SkewbAlgorithmData_free(void* const ptr) {
+  const SkewbAlgorithmData* const data = ptr;
+  free(data->moves);
+  free(ptr);
+}
+
+static size_t SkewbAlgorithmData_size(const void* const ptr) {
+  const SkewbAlgorithmData* const data = ptr;
+  return sizeof(SkewbAlgorithmData) + data->size * sizeof(SkewbMove);
+}
+
+const rb_data_type_t SkewbAlgorithmData_type = {
+  "TwistyPuzzles::Native::SkewbAlgorithmData",
+  {NULL, SkewbAlgorithmData_free, SkewbAlgorithmData_size, NULL},
+  NULL, NULL,
+  RUBY_TYPED_FREE_IMMEDIATELY  
+};
+
+static void check_moves(const SkewbAlgorithmData* const data, const char* const name) {
+  for (size_t i = 0; i < data->size; ++i) {
+    const SkewbMoveType type = data->moves[i].type;
+    if (type != MOVE && type != ROTATION) {
+      rb_raise(rb_eRuntimeError, "invalid move type %d in %s", type, name);
+    }
+  }
+}
+
+static SkewbMove* malloc_moves(const size_t n) {
+  SkewbMove* const moves = malloc(n * sizeof(SkewbMove));
+  if (moves == NULL) {
+    rb_raise(rb_eNoMemError, "Allocating skewb algorithm failed.");
+  }
+  return moves;
+}
+
+static VALUE SkewbAlgorithm_alloc(const VALUE klass) {
+  SkewbAlgorithmData* data;
+  const VALUE object = TypedData_Make_Struct(klass, SkewbAlgorithmData, &SkewbAlgorithmData_type, data);
+  data->size = 0;
+  data->initialized = FALSE;
+  data->moves = NULL;
+  return object;
+}
+
+#define GetSkewbAlgorithmData(obj, data) \
+  do { \
+    TypedData_Get_Struct((obj), SkewbAlgorithmData, &SkewbAlgorithmData_type, (data)); \
+  } while (0)
+
+#define GetInitializedSkewbAlgorithmData(obj, data) \
+  do { \
+    GetSkewbAlgorithmData((obj), (data)); \
+    if (!data->initialized) { \
+      rb_raise(rb_eRuntimeError, "Skewb algorithm isn't initialized."); \
+    } \
+  } while(0)
+
+static SkewbMoveType extract_move_type(const VALUE move_symbol) {
+  Check_Type(move_symbol, T_SYMBOL);
+  const ID move_symbol_id = SYM2ID(move_symbol);
+  if (move_symbol_id == move_id) {
+    return MOVE;
+  } else if (move_symbol_id == rotation_id) {
+    return ROTATION;
+  } else {
+    rb_raise(rb_eArgError, "Got invalid move symbol.");
+  }
+}
+
+static SkewbAxis extract_axis(const SkewbMoveType type, const VALUE axis) {
+  SkewbAxis result;
+  switch (type) {
+  case MOVE:
+    result.corner = extract_corner(axis);
+    return result;
+  case ROTATION:
+    result.face_index = face_index(axis);
+    return result;
+  default:
+    rb_raise(rb_eRuntimeError, "invalid move type %d in extract_axis", type);
+  }
+}
+
+static VALUE SkewbAlgorithm_initialize(const VALUE self, const VALUE moves) {
+  Check_Type(moves, T_ARRAY);
+  SkewbAlgorithmData* data;
+  GetSkewbAlgorithmData(self, data);
+  data->size = RARRAY_LEN(moves);
+  data->initialized = TRUE;
+  data->moves = malloc_moves(data->size);
+  for (size_t i = 0; i < RARRAY_LEN(moves); ++i) {
+    const VALUE move = rb_ary_entry(moves, i);
+    if (RARRAY_LEN(move) != 3) {
+      rb_raise(rb_eArgError, "Moves must have 3 elements. Got %ld.", RARRAY_LEN(moves));
+    }
+    const SkewbMoveType type = extract_move_type(rb_ary_entry(move, 0));
+    data->moves[i].type = type;
+    data->moves[i].axis = extract_axis(type, rb_ary_entry(move, 1));
+    data->moves[i].direction = NUM2INT(rb_ary_entry(move, 2));
+  }
+  return self;
+}
+
+static void apply_move_to(const SkewbMove move, SkewbStateData* const skewb_state) {
+  switch (move.type) {
+  case MOVE:
+    rotate_corner_for_skewb_state(move.axis.corner, move.direction, skewb_state);
+    break;
+  case ROTATION:
+    rotate_skewb_state(move.axis.face_index, move.direction, skewb_state);
+    break;
+  default:
+    rb_raise(rb_eRuntimeError, "invalid move type %d in apply_move_to", move.type);
+  }
+}
+
+static VALUE SkewbAlgorithm_apply_to(const VALUE self, const VALUE skewb_state) {
+  SkewbStateData* skewb_state_data;
+  GetSkewbStateData(skewb_state, skewb_state_data);
+  const SkewbAlgorithmData* data;
+  GetInitializedSkewbAlgorithmData(self, data);
+  for (size_t i = 0; i < data->size; ++i) {
+    apply_move_to(data->moves[i], skewb_state_data);
+  }
+  return Qnil;
+}
+
+// Takes either face_index or the opposite, depending which one is present on corner.
+static face_index_t axis_face_on_corner(const Corner corner, const face_index_t face_index) {
+  for (size_t i = 0; i < 3; ++i) {
+    if (same_axis(corner.face_indices[i], face_index)) {
+      return corner.face_indices[i];
+    }
+  }
+  rb_raise(rb_eRuntimeError, "invalid state in axis_face_on_corner");
+}
+
+bool corners_eq(Corner left, Corner right) {
+  return left.face_indices[0] == right.face_indices[0] &&
+    (left.face_indices[1] == right.face_indices[1] && left.face_indices[2] == right.face_indices[2] ||
+     left.face_indices[1] == right.face_indices[2] && left.face_indices[2] == right.face_indices[1]);
+}
+
+size_t equivalent_corner_index(const FaceCorners corners, const Corner corner) {  
+  for (size_t i = 0; i < 4; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      if (corners_eq(rotated_corner(corners.corners[i], j), corner)) {
+        return i;
+      }
+    }
+  }
+  rb_raise(rb_eRuntimeError, "invalid state in equivalent_corner_index");
+}
+
+static SkewbMove rotate_move_by(const SkewbMove move, const face_index_t rotation_face_index, const direction_t rotation_direction) {
+  SkewbMove result = move;
+  switch (move.type) {
+  case MOVE: {
+    const face_index_t nice_rotation_face_index = axis_face_on_corner(move.axis.corner, rotation_face_index);
+    const face_index_t nice_rotation_direction = rotation_face_index == nice_rotation_face_index ? rotation_direction : invert_cube_direction(rotation_direction);
+    FaceCorners corners = get_face_corners(nice_rotation_face_index);
+    const size_t corner_index = equivalent_corner_index(corners, move.axis.corner);
+    result.axis.corner = corners.corners[(corner_index + nice_rotation_direction) % 4];
+    break;
+  }
+  case ROTATION: {
+    if (!same_axis(move.axis.face_index, rotation_face_index)) {
+      const size_t index = neighbor_index(rotation_face_index, move.axis.face_index);
+      result.axis.face_index = neighbor_face_index(rotation_face_index, index + rotation_direction);
+    }
+    break;
+  }
+  default:
+    rb_raise(rb_eRuntimeError, "invalid move type %d in rotate_move_by", move.type);
+  }
+  return result;
+}
+
+static VALUE SkewbAlgorithm_rotate_by(const VALUE self, const VALUE rotation_face_symbol, const VALUE direction) {
+  const face_index_t rotation_face_index = face_index(rotation_face_symbol);
+  const direction_t rotation_direction = NUM2INT(direction);
+  const SkewbAlgorithmData* data;
+  GetInitializedSkewbAlgorithmData(self, data);
+  SkewbAlgorithmData* rotated_data;
+  const VALUE rotated = TypedData_Make_Struct(SkewbAlgorithmClass, SkewbAlgorithmData, &SkewbAlgorithmData_type, rotated_data);
+  rotated_data->size = data->size;
+  rotated_data->initialized = TRUE;
+  rotated_data->moves = malloc_moves(rotated_data->size);
+  for (size_t i = 0; i < data->size; ++i) {
+    rotated_data->moves[i] = rotate_move_by(data->moves[i], rotation_face_index, rotation_direction);
+  }
+  return rotated;
+}
+
+static SkewbMove mirror_move(const SkewbMove move, const face_index_t normal_face_index) {
+  SkewbMove result = move;
+  switch (move.type) {
+  case MOVE: {
+    for (size_t i = 0; i < 3; ++i) {
+      const face_index_t current_face_index = move.axis.corner.face_indices[i];
+      if (same_axis(current_face_index, normal_face_index)) {
+        // We need to make one face into the opposite and then swap to to fix the chirality.
+        result.axis.corner.face_indices[(i + 1) % 3] = opposite_face_index(current_face_index);
+        result.axis.corner.face_indices[i] = move.axis.corner.face_indices[(i + 1) % 3];
+        break;
+      }
+    }
+    result.direction = invert_skewb_direction(move.direction);
+    break;
+  }
+  case ROTATION: {
+    if (!same_axis(move.axis.face_index, normal_face_index)) {
+      result.direction = invert_cube_direction(move.direction);
+    }
+    break;
+  }
+  default:
+    rb_raise(rb_eRuntimeError, "invalid move type %d in mirror_move", move.type);
+  }
+  return result;
+}
+
+static VALUE SkewbAlgorithm_mirror(const VALUE self, const VALUE normal_face_symbol) {
+  const face_index_t normal_face_index = face_index(normal_face_symbol);
+  const SkewbAlgorithmData* data;
+  GetInitializedSkewbAlgorithmData(self, data);
+  SkewbAlgorithmData* mirrored_data;
+  const VALUE mirrored = TypedData_Make_Struct(SkewbAlgorithmClass, SkewbAlgorithmData, &SkewbAlgorithmData_type, mirrored_data);
+  mirrored_data->size = data->size;
+  mirrored_data->initialized = TRUE;
+  mirrored_data->moves = malloc_moves(mirrored_data->size);
+  for (size_t i = 0; i < data->size; ++i) {
+    mirrored_data->moves[i] = mirror_move(data->moves[i], normal_face_index);
+  }
+  return mirrored;
+}
+
+static SkewbMove invert_move(const SkewbMove move) {
+  SkewbMove result = move;
+  switch (move.type) {
+  case MOVE:
+    result.direction = invert_skewb_direction(result.direction);
+    break;
+  case ROTATION:
+    result.direction = invert_cube_direction(result.direction);
+    break;
+  default:
+    rb_raise(rb_eRuntimeError, "invalid move type %d in invert_move", move.type);
+  }
+  return result;
+}
+
+static VALUE SkewbAlgorithm_inverse(const VALUE self) {
+  const SkewbAlgorithmData* data;
+  GetInitializedSkewbAlgorithmData(self, data);
+  SkewbAlgorithmData* inverted_data;
+  const VALUE inverted = TypedData_Make_Struct(SkewbAlgorithmClass, SkewbAlgorithmData, &SkewbAlgorithmData_type, inverted_data);
+  inverted_data->size = data->size;
+  inverted_data->initialized = TRUE;
+  inverted_data->moves = malloc_moves(inverted_data->size);
+  for (size_t i = 0; i < data->size; ++i) {
+    inverted_data->moves[i] = invert_move(data->moves[data->size - 1 - i]);
+  }
+  return inverted;
+}
+
+static VALUE SkewbAlgorithm_plus(const VALUE self, const VALUE other) {
+  const SkewbAlgorithmData* self_data;
+  GetInitializedSkewbAlgorithmData(self, self_data);
+  const SkewbAlgorithmData* other_data;
+  GetInitializedSkewbAlgorithmData(other, other_data);
+  SkewbAlgorithmData* sum_data;
+  const VALUE sum = TypedData_Make_Struct(SkewbAlgorithmClass, SkewbAlgorithmData, &SkewbAlgorithmData_type, sum_data);
+  sum_data->size = self_data->size + other_data->size;
+  sum_data->initialized = TRUE;
+  sum_data->moves = malloc_moves(sum_data->size);
+  for (size_t i = 0; i < self_data->size; ++i) {
+    sum_data->moves[i] = self_data->moves[i];
+  }
+  for (size_t i = 0; i < other_data->size; ++i) {
+    sum_data->moves[self_data->size + i] = other_data->moves[i];
+  }
+  return sum;
+}
+
+void init_skewb_algorithm_class_under(const VALUE module) {
+  move_id = rb_intern("move");
+  rotation_id = rb_intern("rotation");
+  SkewbAlgorithmClass = rb_define_class_under(module, "SkewbAlgorithm", rb_cObject);
+  rb_define_alloc_func(SkewbAlgorithmClass, SkewbAlgorithm_alloc);
+  rb_define_method(SkewbAlgorithmClass, "initialize", SkewbAlgorithm_initialize, 1);
+  rb_define_method(SkewbAlgorithmClass, "apply_to", SkewbAlgorithm_apply_to, 1);
+  rb_define_method(SkewbAlgorithmClass, "rotate_by", SkewbAlgorithm_rotate_by, 2);
+  rb_define_method(SkewbAlgorithmClass, "mirror", SkewbAlgorithm_mirror, 1);
+  rb_define_method(SkewbAlgorithmClass, "inverse", SkewbAlgorithm_inverse, 0);
+  rb_define_method(SkewbAlgorithmClass, "+", SkewbAlgorithm_plus, 1);
+}