@cubingcenter/scrambler 0.2.0 → 0.4.0

package/dist-cjs/puzzles/skewb/state.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSolvedSkewbState = createSolvedSkewbState;
+exports.cloneSkewbState = cloneSkewbState;
+exports.skewbStatesEqual = skewbStatesEqual;
+exports.isSolvedSkewbState = isSolvedSkewbState;
+function createSolvedSkewbState() {
+    return {
+        corners: {
+            permutation: [0, 1, 2, 3, 4, 5, 6, 7],
+            orientation: [0, 0, 0, 0, 0, 0, 0, 0],
+        },
+        centers: [0, 1, 2, 3, 4, 5],
+    };
+}
+function cloneSkewbState(state) {
+    return {
+        corners: {
+            permutation: [...state.corners.permutation],
+            orientation: [...state.corners.orientation],
+        },
+        centers: [...state.centers],
+    };
+}
+function skewbStatesEqual(left, right) {
+    return (arraysEqual(left.corners.permutation, right.corners.permutation) &&
+        arraysEqual(left.corners.orientation, right.corners.orientation) &&
+        arraysEqual(left.centers, right.centers));
+}
+function isSolvedSkewbState(state) {
+    return (state.corners.permutation.every((value, index) => value === index) &&
+        state.corners.orientation.every((value) => value === 0) &&
+        state.centers.every((value, index) => value === index));
+}
+function arraysEqual(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}

package/dist-cjs/puzzles/skewb/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKEWB_FACES = exports.SKEWB_MOVES = exports.CENTER_COUNT = exports.CORNER_COUNT = void 0;
+exports.CORNER_COUNT = 8;
+exports.CENTER_COUNT = 6;
+exports.SKEWB_MOVES = [
+    "R",
+    "R'",
+    "U",
+    "U'",
+    "L",
+    "L'",
+    "B",
+    "B'",
+];
+exports.SKEWB_FACES = ["U", "R", "F", "D", "L", "B"];

package/dist-cjs/puzzles/skewb/validation.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSkewbState = validateSkewbState;
+exports.isOneMoveFromSolvedSkewbState = isOneMoveFromSolvedSkewbState;
+exports.isAllowedRandomSkewbState = isAllowedRandomSkewbState;
+exports.permutationParity = permutationParity;
+const types_js_1 = require("./types.js");
+const moves_js_1 = require("./moves.js");
+const state_js_1 = require("./state.js");
+function validateSkewbState(state) {
+    const errors = [];
+    // corners permutation
+    errors.push(...validatePermutation("corner", state.corners.permutation, types_js_1.CORNER_COUNT));
+    // corners orientation
+    errors.push(...validateOrientations("corner", state.corners.orientation, types_js_1.CORNER_COUNT, 3));
+    // centers
+    errors.push(...validatePermutation("center", state.centers, types_js_1.CENTER_COUNT));
+    // parity checks - both perms must be even (as observed in BFS)
+    if (errors.length === 0) {
+        if (permutationParity(state.corners.permutation) !== 0) {
+            errors.push("Corner permutation parity must be even.");
+        }
+        if (permutationParity(state.centers) !== 0) {
+            errors.push("Center permutation parity must be even.");
+        }
+        // Check fixed corner invariant: corner 0 must be at position 0 with orientation 0 for WCA fixed model
+        // But we allow all states for validation; this is enforced by solver's reachable set, not validation.
+        // So we don't enforce fixed corner here; any even parity state is considered valid.
+    }
+    return { valid: errors.length === 0, errors };
+}
+function isOneMoveFromSolvedSkewbState(state) {
+    const solved = (0, state_js_1.createSolvedSkewbState)();
+    return types_js_1.SKEWB_MOVES.some((move) => (0, state_js_1.skewbStatesEqual)((0, moves_js_1.applySkewbMove)(solved, move), state));
+}
+function isAllowedRandomSkewbState(state) {
+    return validateSkewbState(state).valid && !(0, state_js_1.isSolvedSkewbState)(state) && !isOneMoveFromSolvedSkewbState(state);
+}
+function permutationParity(permutation) {
+    let inversions = 0;
+    for (let left = 0; left < permutation.length; left++) {
+        for (let right = left + 1; right < permutation.length; right++) {
+            if (permutation[left] > permutation[right])
+                inversions++;
+        }
+    }
+    return (inversions % 2);
+}
+function validatePermutation(label, permutation, length) {
+    const errors = [];
+    const seen = new Set();
+    if (permutation.length !== length)
+        errors.push(`${label} permutation must contain ${length} values.`);
+    for (const value of permutation) {
+        if (!Number.isInteger(value) || value < 0 || value >= length) {
+            errors.push(`${label} permutation contains out-of-range value: ${value}.`);
+            continue;
+        }
+        if (seen.has(value))
+            errors.push(`${label} permutation contains duplicate value: ${value}.`);
+        seen.add(value);
+    }
+    return errors;
+}
+function validateOrientations(label, orientations, length, modulo) {
+    const errors = [];
+    if (orientations.length !== length)
+        errors.push(`${label} orientation must contain ${length} values.`);
+    for (const value of orientations) {
+        if (!Number.isInteger(value) || value < 0 || value >= modulo) {
+            errors.push(`${label} orientation contains out-of-range value: ${value}.`);
+        }
+    }
+    return errors;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubingcenter/scrambler",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Extensible scramble generation toolkit for CubingCenter projects.",
   "type": "module",
   "license": "MIT",