@cubingcenter/scrambler 0.4.1 → 0.5.1

package/dist-cjs/puzzles/skewb/solver/search.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solveSkewb = solveSkewb;
+exports.solveSkewbWithInfo = solveSkewbWithInfo;
+exports.solveSkewbIndices = solveSkewbIndices;
+exports.solveSkewbIndicesSync = solveSkewbIndicesSync;
+exports.solveSkewbSync = solveSkewbSync;
+exports.verifySkewbScramble = verifySkewbScramble;
+exports.verifySkewbScrambleIndices = verifySkewbScrambleIndices;
+exports.verifySkewbSolution = verifySkewbSolution;
+const tables_js_1 = require("./tables.js");
+async function solveSkewb(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTables(state).moves;
+}
+async function solveSkewbWithInfo(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTables(state);
+}
+// Index-based solve for the hot scramble path: returns the solution as move
+// indices (0..7) in walk order. The inverse of index m is m ^ 1 (moves are
+// paired R/R', U/U', L/L', B/B').
+async function solveSkewbIndices(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTablesIndices(state);
+}
+function solveSkewbIndicesSync(state) {
+    if (!tables_js_1.POLICY_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return solveWithTablesIndices(state);
+}
+// Synchronous variant for scripts that have already ensured tables are loaded
+function solveSkewbSync(state) {
+    if (!tables_js_1.POLICY_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return solveWithTables(state).moves;
+}
+function solveWithTables(state) {
+    const indices = solveWithTablesIndices(state);
+    const moves = indices.map((index) => tables_js_1.SKEWB_MOVES[index]);
+    return { moves, depth: moves.length };
+}
+function solveWithTablesIndices(state) {
+    const policy = tables_js_1.POLICY_TABLE;
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    const centersTable = tables_js_1.CENTERS_TABLE;
+    if (state.corners.permutation[0] !== 0) {
+        throw new Error("The Skewb solver requires the UFR corner (index 0) to be fixed " +
+            "as the frame of reference. Please normalize the state before solving.");
+    }
+    let r7 = (0, tables_js_1.getPerm7Index)(state.corners.permutation);
+    let rO = (0, tables_js_1.getOrientationIndex)(state.corners.orientation);
+    let rC = (0, tables_js_1.getCenterIndex)(state.centers);
+    let rank = (0, tables_js_1.rankFromComponents)(r7, rO, rC);
+    if (rank === tables_js_1.SOLVED_RANK) {
+        return [];
+    }
+    const moves = [];
+    while (rank !== tables_js_1.SOLVED_RANK) {
+        const m = (0, tables_js_1.getPolicyMoveFromPacked)(policy, rank);
+        moves.push(m);
+        r7 = permTable[r7 * tables_js_1.MOVE_COUNT + m];
+        rO = orientTable[rO * tables_js_1.MOVE_COUNT + m];
+        rC = centersTable[rC * tables_js_1.MOVE_COUNT + m];
+        rank = (0, tables_js_1.rankFromComponents)(r7, rO, rC);
+    }
+    return moves;
+}
+// ---------------------------------------------------------------------------
+// Coordinate-walking verification (no full state clones)
+// ---------------------------------------------------------------------------
+const MOVE_INDEX = {};
+for (let i = 0; i < tables_js_1.SKEWB_MOVES.length; i++) {
+    MOVE_INDEX[tables_js_1.SKEWB_MOVES[i]] = i;
+}
+function walkSkewbCoordinates(start, moves) {
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    const centersTable = tables_js_1.CENTERS_TABLE;
+    if (!permTable || !orientTable || !centersTable) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let { r7, rO, rC } = start;
+    for (const move of moves) {
+        const m = MOVE_INDEX[move];
+        r7 = permTable[r7 * tables_js_1.MOVE_COUNT + m];
+        rO = orientTable[rO * tables_js_1.MOVE_COUNT + m];
+        rC = centersTable[rC * tables_js_1.MOVE_COUNT + m];
+    }
+    return { r7, rO, rC };
+}
+function verifySkewbScramble(state, scrambleMoves) {
+    const final = walkSkewbCoordinates({ r7: 0, rO: 0, rC: 0 }, scrambleMoves);
+    return (final.r7 === (0, tables_js_1.getPerm7Index)(state.corners.permutation) &&
+        final.rO === (0, tables_js_1.getOrientationIndex)(state.corners.orientation) &&
+        final.rC === (0, tables_js_1.getCenterIndex)(state.centers));
+}
+// Numeric verification for the hot scramble path: replays the scramble (the
+// solution reversed with m ^ 1 inverses) without any string parsing.
+function verifySkewbScrambleIndices(state, solution) {
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    const centersTable = tables_js_1.CENTERS_TABLE;
+    if (!permTable || !orientTable || !centersTable) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let r7 = 0;
+    let rO = 0;
+    let rC = 0;
+    for (let index = solution.length - 1; index >= 0; index -= 1) {
+        const m = solution[index] ^ 1;
+        r7 = permTable[r7 * tables_js_1.MOVE_COUNT + m];
+        rO = orientTable[rO * tables_js_1.MOVE_COUNT + m];
+        rC = centersTable[rC * tables_js_1.MOVE_COUNT + m];
+    }
+    return (r7 === (0, tables_js_1.getPerm7Index)(state.corners.permutation) &&
+        rO === (0, tables_js_1.getOrientationIndex)(state.corners.orientation) &&
+        rC === (0, tables_js_1.getCenterIndex)(state.centers));
+}
+function verifySkewbSolution(state, solutionMoves) {
+    const final = walkSkewbCoordinates({
+        r7: (0, tables_js_1.getPerm7Index)(state.corners.permutation),
+        rO: (0, tables_js_1.getOrientationIndex)(state.corners.orientation),
+        rC: (0, tables_js_1.getCenterIndex)(state.centers)
+    }, solutionMoves);
+    return final.r7 === 0 && final.rO === 0 && final.rC === 0;
+}

package/dist-cjs/puzzles/skewb/solver/table-metadata.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKEWB_SOLVER_TABLE_METADATA = void 0;
+exports.SKEWB_SOLVER_TABLE_METADATA = {
+    permutationTable: {
+        entries: 40320, // PERMUTATION_COUNT (5040) * MOVE_COUNT (8)
+        checksum: 3073532981
+    },
+    orientationTable: {
+        entries: 17496, // ORIENTATION_COUNT (2187) * MOVE_COUNT (8)
+        checksum: 2128852053
+    },
+    centersTable: {
+        entries: 5760, // CENTER_COUNT (720) * MOVE_COUNT (8)
+        checksum: 360885765
+    },
+    helpers: {
+        evenCenterRankBytes: 1440, // 720 * 2 (Uint16, sentinel 65535)
+        orientClassBytes: 2187,
+        r7SetsEntries: 12960, // EVEN_CENTER_COUNT (360) * ORIENT_CLASS_COUNT (9) * PER_SET_SIZE (4)
+        entries: 1440 + 2187 + 12960 * 2,
+        checksum: 4284555735
+    },
+    policyTable: {
+        entries: 1180980, // ceil(STATE_COUNT (3_149_280) * 3 / 8)
+        checksum: 1294485891,
+        maxDepth: 11
+    }
+};