@cubingcenter/scrambler 0.1.0

package/dist-cjs/puzzles/cube3/solver/coordinates.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUBE3_COORDINATE_RANGES = void 0;
+exports.encodeCube3Coordinates = encodeCube3Coordinates;
+exports.encodeCube3Coordinate = encodeCube3Coordinate;
+exports.encodeCornerOrientation = encodeCornerOrientation;
+exports.decodeCornerOrientation = decodeCornerOrientation;
+exports.encodeEdgeOrientation = encodeEdgeOrientation;
+exports.decodeEdgeOrientation = decodeEdgeOrientation;
+exports.encodeUdSlice = encodeUdSlice;
+exports.decodeUdSlice = decodeUdSlice;
+exports.encodeUdEdgePermutation = encodeUdEdgePermutation;
+exports.decodeUdEdgePermutation = decodeUdEdgePermutation;
+exports.encodeSlicePermutation = encodeSlicePermutation;
+exports.decodeSlicePermutation = decodeSlicePermutation;
+exports.decodePermutation = decodePermutation;
+exports.encodePermutation = encodePermutation;
+exports.createRepresentativeStateForCoordinate = createRepresentativeStateForCoordinate;
+exports.moveCoordinate = moveCoordinate;
+const moves_js_1 = require("../moves.js");
+const state_js_1 = require("../state.js");
+const types_js_1 = require("../types.js");
+exports.CUBE3_COORDINATE_RANGES = {
+    cornerOrientation: 2187,
+    edgeOrientation: 2048,
+    udSlice: 495,
+    cornerPermutation: 40320,
+    udEdgePermutation: 40320,
+    slicePermutation: 24
+};
+const SLICE_EDGE_START = 8;
+const UD_EDGE_COUNT = 8;
+const SLICE_EDGE_COUNT = 4;
+const UD_SLICE_COMBINATIONS = createCombinations(types_js_1.EDGE_COUNT, SLICE_EDGE_COUNT);
+const UD_SLICE_INDEX_BY_KEY = new Map(UD_SLICE_COMBINATIONS.map((combination, index) => [combination.join(","), index]));
+function encodeCube3Coordinates(state) {
+    return {
+        cornerOrientation: encodeCornerOrientation(state),
+        edgeOrientation: encodeEdgeOrientation(state),
+        udSlice: encodeUdSlice(state),
+        cornerPermutation: encodePermutation(state.corners.permutation),
+        udEdgePermutation: encodeUdEdgePermutation(state),
+        slicePermutation: encodeSlicePermutation(state)
+    };
+}
+function encodeCube3Coordinate(coordinateName, state) {
+    if (coordinateName === "cornerOrientation") {
+        return encodeCornerOrientation(state);
+    }
+    if (coordinateName === "edgeOrientation") {
+        return encodeEdgeOrientation(state);
+    }
+    if (coordinateName === "udSlice") {
+        return encodeUdSlice(state);
+    }
+    if (coordinateName === "cornerPermutation") {
+        return encodePermutation(state.corners.permutation);
+    }
+    if (coordinateName === "udEdgePermutation") {
+        return encodeUdEdgePermutation(state);
+    }
+    return encodeSlicePermutation(state);
+}
+function encodeCornerOrientation(state) {
+    assertLength(state.corners.orientation, types_js_1.CORNER_COUNT, "corner orientation");
+    let coordinate = 0;
+    for (let index = 0; index < types_js_1.CORNER_COUNT - 1; index += 1) {
+        const orientation = state.corners.orientation[index];
+        assertRange(orientation, 0, 2, "corner orientation");
+        coordinate = coordinate * 3 + orientation;
+    }
+    return coordinate;
+}
+function decodeCornerOrientation(coordinate) {
+    assertCoordinate(coordinate, exports.CUBE3_COORDINATE_RANGES.cornerOrientation, "corner orientation");
+    const orientations = Array(types_js_1.CORNER_COUNT).fill(0);
+    let remaining = coordinate;
+    let total = 0;
+    for (let index = types_js_1.CORNER_COUNT - 2; index >= 0; index -= 1) {
+        const orientation = remaining % 3;
+        orientations[index] = orientation;
+        total += orientation;
+        remaining = Math.floor(remaining / 3);
+    }
+    orientations[types_js_1.CORNER_COUNT - 1] = (3 - (total % 3)) % 3;
+    return orientations;
+}
+function encodeEdgeOrientation(state) {
+    assertLength(state.edges.orientation, types_js_1.EDGE_COUNT, "edge orientation");
+    let coordinate = 0;
+    for (let index = 0; index < types_js_1.EDGE_COUNT - 1; index += 1) {
+        const orientation = state.edges.orientation[index];
+        assertRange(orientation, 0, 1, "edge orientation");
+        coordinate = coordinate * 2 + orientation;
+    }
+    return coordinate;
+}
+function decodeEdgeOrientation(coordinate) {
+    assertCoordinate(coordinate, exports.CUBE3_COORDINATE_RANGES.edgeOrientation, "edge orientation");
+    const orientations = Array(types_js_1.EDGE_COUNT).fill(0);
+    let remaining = coordinate;
+    let total = 0;
+    for (let index = types_js_1.EDGE_COUNT - 2; index >= 0; index -= 1) {
+        const orientation = remaining % 2;
+        orientations[index] = orientation;
+        total += orientation;
+        remaining = Math.floor(remaining / 2);
+    }
+    orientations[types_js_1.EDGE_COUNT - 1] = total % 2;
+    return orientations;
+}
+function encodeUdSlice(state) {
+    assertLength(state.edges.permutation, types_js_1.EDGE_COUNT, "edge permutation");
+    const positions = state.edges.permutation
+        .map((piece, position) => ({ piece, position }))
+        .filter(({ piece }) => piece >= SLICE_EDGE_START)
+        .map(({ position }) => position);
+    if (positions.length !== SLICE_EDGE_COUNT) {
+        throw new RangeError("UD slice coordinate requires exactly four slice edges.");
+    }
+    const key = positions.join(",");
+    const coordinate = UD_SLICE_INDEX_BY_KEY.get(key);
+    if (coordinate === undefined) {
+        throw new RangeError(`Invalid UD slice positions: ${key}`);
+    }
+    return coordinate;
+}
+function decodeUdSlice(coordinate) {
+    assertCoordinate(coordinate, exports.CUBE3_COORDINATE_RANGES.udSlice, "UD slice");
+    return [...UD_SLICE_COMBINATIONS[coordinate]];
+}
+function encodeUdEdgePermutation(state) {
+    assertLength(state.edges.permutation, types_js_1.EDGE_COUNT, "edge permutation");
+    const permutation = state.edges.permutation.slice(0, UD_EDGE_COUNT);
+    if (permutation.some((piece) => piece < 0 || piece >= UD_EDGE_COUNT)) {
+        throw new RangeError("UD edge permutation requires UD edges in UD edge positions.");
+    }
+    return encodePermutation(permutation);
+}
+function decodeUdEdgePermutation(coordinate) {
+    return decodePermutation(coordinate, UD_EDGE_COUNT);
+}
+function encodeSlicePermutation(state) {
+    assertLength(state.edges.permutation, types_js_1.EDGE_COUNT, "edge permutation");
+    const permutation = state.edges.permutation
+        .slice(SLICE_EDGE_START)
+        .map((piece) => piece - SLICE_EDGE_START);
+    if (permutation.some((piece) => piece < 0 || piece >= SLICE_EDGE_COUNT)) {
+        throw new RangeError("Slice permutation requires slice edges in slice positions.");
+    }
+    return encodePermutation(permutation);
+}
+function decodeSlicePermutation(coordinate) {
+    return decodePermutation(coordinate, SLICE_EDGE_COUNT).map((piece) => piece + SLICE_EDGE_START);
+}
+function decodePermutation(coordinate, length) {
+    assertCoordinate(coordinate, factorial(length), `permutation length ${length}`);
+    const available = Array.from({ length }, (_, index) => index);
+    const permutation = [];
+    let remaining = coordinate;
+    for (let index = length; index > 0; index -= 1) {
+        const placeValue = factorial(index - 1);
+        const selected = Math.floor(remaining / placeValue);
+        permutation.push(available.splice(selected, 1)[0]);
+        remaining %= placeValue;
+    }
+    return permutation;
+}
+function encodePermutation(permutation) {
+    validatePermutation(permutation);
+    const available = Array.from({ length: permutation.length }, (_, index) => index);
+    let coordinate = 0;
+    for (let index = 0; index < permutation.length; index += 1) {
+        const value = permutation[index];
+        const selected = available.indexOf(value);
+        coordinate += selected * factorial(permutation.length - index - 1);
+        available.splice(selected, 1);
+    }
+    return coordinate;
+}
+function createRepresentativeStateForCoordinate(coordinateName, coordinate) {
+    const state = (0, state_js_1.createSolvedCube3State)();
+    if (coordinateName === "cornerOrientation") {
+        state.corners.orientation = decodeCornerOrientation(coordinate);
+    }
+    else if (coordinateName === "edgeOrientation") {
+        state.edges.orientation = decodeEdgeOrientation(coordinate);
+    }
+    else if (coordinateName === "udSlice") {
+        const slicePositions = new Set(decodeUdSlice(coordinate));
+        const edgePermutation = Array(types_js_1.EDGE_COUNT).fill(-1);
+        let udEdge = 0;
+        let sliceEdge = SLICE_EDGE_START;
+        for (let position = 0; position < types_js_1.EDGE_COUNT; position += 1) {
+            if (slicePositions.has(position)) {
+                edgePermutation[position] = sliceEdge;
+                sliceEdge += 1;
+            }
+            else {
+                edgePermutation[position] = udEdge;
+                udEdge += 1;
+            }
+        }
+        state.edges.permutation = edgePermutation;
+    }
+    else if (coordinateName === "cornerPermutation") {
+        state.corners.permutation = decodePermutation(coordinate, types_js_1.CORNER_COUNT);
+    }
+    else if (coordinateName === "udEdgePermutation") {
+        state.edges.permutation = [
+            ...decodeUdEdgePermutation(coordinate),
+            8,
+            9,
+            10,
+            11
+        ];
+    }
+    else {
+        state.edges.permutation = [
+            0,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            ...decodeSlicePermutation(coordinate)
+        ];
+    }
+    return state;
+}
+function moveCoordinate(coordinateName, coordinate, move) {
+    const state = createRepresentativeStateForCoordinate(coordinateName, coordinate);
+    const moved = (0, moves_js_1.applyCube3Move)(state, move);
+    return encodeCube3Coordinate(coordinateName, moved);
+}
+function createCombinations(size, selected) {
+    const combinations = [];
+    function visit(start, current) {
+        if (current.length === selected) {
+            combinations.push([...current]);
+            return;
+        }
+        for (let value = start; value <= size - (selected - current.length); value += 1) {
+            current.push(value);
+            visit(value + 1, current);
+            current.pop();
+        }
+    }
+    visit(0, []);
+    return combinations;
+}
+function validatePermutation(permutation) {
+    const seen = new Set();
+    for (const value of permutation) {
+        assertRange(value, 0, permutation.length - 1, "permutation value");
+        if (seen.has(value)) {
+            throw new RangeError(`Permutation contains duplicate value: ${value}`);
+        }
+        seen.add(value);
+    }
+}
+function assertLength(values, expected, label) {
+    if (values.length !== expected) {
+        throw new RangeError(`${label} must contain ${expected} values.`);
+    }
+}
+function assertRange(value, min, max, label) {
+    if (!Number.isInteger(value) || value < min || value > max) {
+        throw new RangeError(`${label} must be an integer between ${min} and ${max}. Received: ${value}`);
+    }
+}
+function assertCoordinate(value, range, label) {
+    if (!Number.isInteger(value) || value < 0 || value >= range) {
+        throw new RangeError(`${label} coordinate must be between 0 and ${range - 1}. Received: ${value}`);
+    }
+}
+function factorial(value) {
+    let result = 1;
+    for (let factor = 2; factor <= value; factor += 1) {
+        result *= factor;
+    }
+    return result;
+}

package/dist-cjs/puzzles/cube3/solver/generated/manifest.json

@@ -0,0 +1,404 @@
+{
+  "version": 1,
+  "phase1Moves": [
+    "U",
+    "U2",
+    "U'",
+    "D",
+    "D2",
+    "D'",
+    "R",
+    "R2",
+    "R'",
+    "L",
+    "L2",
+    "L'",
+    "F",
+    "F2",
+    "F'",
+    "B",
+    "B2",
+    "B'"
+  ],
+  "phase2Moves": [
+    "U",
+    "U2",
+    "U'",
+    "D",
+    "D2",
+    "D'",
+    "R2",
+    "L2",
+    "F2",
+    "B2"
+  ],
+  "moveTables": {
+    "cornerOrientation": {
+      "coordinate": "cornerOrientation",
+      "file": "move-cornerOrientation.bin",
+      "kind": "move",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R",
+        "R2",
+        "R'",
+        "L",
+        "L2",
+        "L'",
+        "F",
+        "F2",
+        "F'",
+        "B",
+        "B2",
+        "B'"
+      ],
+      "range": 2187,
+      "solvedCoordinate": 0,
+      "checksum": 404550471
+    },
+    "edgeOrientation": {
+      "coordinate": "edgeOrientation",
+      "file": "move-edgeOrientation.bin",
+      "kind": "move",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R",
+        "R2",
+        "R'",
+        "L",
+        "L2",
+        "L'",
+        "F",
+        "F2",
+        "F'",
+        "B",
+        "B2",
+        "B'"
+      ],
+      "range": 2048,
+      "solvedCoordinate": 0,
+      "checksum": 2992539525
+    },
+    "udSlice": {
+      "coordinate": "udSlice",
+      "file": "move-udSlice.bin",
+      "kind": "move",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R",
+        "R2",
+        "R'",
+        "L",
+        "L2",
+        "L'",
+        "F",
+        "F2",
+        "F'",
+        "B",
+        "B2",
+        "B'"
+      ],
+      "range": 495,
+      "solvedCoordinate": 494,
+      "checksum": 4272096359
+    },
+    "cornerPermutation": {
+      "coordinate": "cornerPermutation",
+      "file": "move-cornerPermutation.bin",
+      "kind": "move",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R2",
+        "L2",
+        "F2",
+        "B2"
+      ],
+      "range": 40320,
+      "solvedCoordinate": 0,
+      "checksum": 3774927605
+    },
+    "udEdgePermutation": {
+      "coordinate": "udEdgePermutation",
+      "file": "move-udEdgePermutation.bin",
+      "kind": "move",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R2",
+        "L2",
+        "F2",
+        "B2"
+      ],
+      "range": 40320,
+      "solvedCoordinate": 0,
+      "checksum": 400302421
+    },
+    "slicePermutation": {
+      "coordinate": "slicePermutation",
+      "file": "move-slicePermutation.bin",
+      "kind": "move",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R2",
+        "L2",
+        "F2",
+        "B2"
+      ],
+      "range": 24,
+      "solvedCoordinate": 0,
+      "checksum": 3510358217
+    }
+  },
+  "pruningTables": {
+    "cornerOrientation": {
+      "coordinate": "cornerOrientation",
+      "file": "pruning-cornerOrientation.bin",
+      "kind": "pruning",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R",
+        "R2",
+        "R'",
+        "L",
+        "L2",
+        "L'",
+        "F",
+        "F2",
+        "F'",
+        "B",
+        "B2",
+        "B'"
+      ],
+      "range": 2187,
+      "solvedCoordinate": 0,
+      "checksum": 1708398310,
+      "maxDepth": 6
+    },
+    "edgeOrientation": {
+      "coordinate": "edgeOrientation",
+      "file": "pruning-edgeOrientation.bin",
+      "kind": "pruning",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R",
+        "R2",
+        "R'",
+        "L",
+        "L2",
+        "L'",
+        "F",
+        "F2",
+        "F'",
+        "B",
+        "B2",
+        "B'"
+      ],
+      "range": 2048,
+      "solvedCoordinate": 0,
+      "checksum": 1305811170,
+      "maxDepth": 7
+    },
+    "udSlice": {
+      "coordinate": "udSlice",
+      "file": "pruning-udSlice.bin",
+      "kind": "pruning",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R",
+        "R2",
+        "R'",
+        "L",
+        "L2",
+        "L'",
+        "F",
+        "F2",
+        "F'",
+        "B",
+        "B2",
+        "B'"
+      ],
+      "range": 495,
+      "solvedCoordinate": 494,
+      "checksum": 1205412689,
+      "maxDepth": 5
+    },
+    "cornerOrientationEdgeOrientation": {
+      "coordinate": "cornerOrientationEdgeOrientation",
+      "file": "pruning-cornerOrientationEdgeOrientation.bin",
+      "kind": "pruning",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R",
+        "R2",
+        "R'",
+        "L",
+        "L2",
+        "L'",
+        "F",
+        "F2",
+        "F'",
+        "B",
+        "B2",
+        "B'"
+      ],
+      "range": 4478976,
+      "solvedCoordinate": 0,
+      "checksum": 3003139252,
+      "maxDepth": 9
+    },
+    "cornerPermutation": {
+      "coordinate": "cornerPermutation",
+      "file": "pruning-cornerPermutation.bin",
+      "kind": "pruning",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R2",
+        "L2",
+        "F2",
+        "B2"
+      ],
+      "range": 40320,
+      "solvedCoordinate": 0,
+      "checksum": 2124468218,
+      "maxDepth": 13
+    },
+    "udEdgePermutation": {
+      "coordinate": "udEdgePermutation",
+      "file": "pruning-udEdgePermutation.bin",
+      "kind": "pruning",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R2",
+        "L2",
+        "F2",
+        "B2"
+      ],
+      "range": 40320,
+      "solvedCoordinate": 0,
+      "checksum": 3536968007,
+      "maxDepth": 8
+    },
+    "slicePermutation": {
+      "coordinate": "slicePermutation",
+      "file": "pruning-slicePermutation.bin",
+      "kind": "pruning",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R2",
+        "L2",
+        "F2",
+        "B2"
+      ],
+      "range": 24,
+      "solvedCoordinate": 0,
+      "checksum": 2803408469,
+      "maxDepth": 4
+    },
+    "cornerPermutationSlicePermutation": {
+      "coordinate": "cornerPermutationSlicePermutation",
+      "file": "pruning-cornerPermutationSlicePermutation.bin",
+      "kind": "pruning",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R2",
+        "L2",
+        "F2",
+        "B2"
+      ],
+      "range": 967680,
+      "solvedCoordinate": 0,
+      "checksum": 4187188769,
+      "maxDepth": 14
+    },
+    "udEdgePermutationSlicePermutation": {
+      "coordinate": "udEdgePermutationSlicePermutation",
+      "file": "pruning-udEdgePermutationSlicePermutation.bin",
+      "kind": "pruning",
+      "moves": [
+        "U",
+        "U2",
+        "U'",
+        "D",
+        "D2",
+        "D'",
+        "R2",
+        "L2",
+        "F2",
+        "B2"
+      ],
+      "range": 967680,
+      "solvedCoordinate": 0,
+      "checksum": 2840452350,
+      "maxDepth": 12
+    }
+  }
+}

package/dist-cjs/puzzles/cube3/solver/generated/pruning-cornerOrientation.bin

@@ -0,0 +1 @@
+PVUeeUUVcUe6eUDCU3CDETEETDdESDCDDcUDT4TTESDED4DUDUDTScCEEUETUVEUUUFeTTRRUDUETRETTDEDS3dTTTCTTTSETDDUUTEEeUUTSUDUUFUTTTUVUD3TDDDUSEECTdC5TBEDDEDUSTEUUEUETTTEUDTTU4EEUEUUeTVUEUTTEDU5ETETTDcUSD5$UTE4DDS3Te$TUQRDUTTEBUUCTDdR4UUDT5T5DT3BU4UE4SDSTDET53DDdETTDTCUEUUTEDUEUTUDES$ESTCUTUTDDDTDESEUUdTEUTUEUEeDSEVUeeDTFEDCVBT3TUTD5UETTUCeUUTUdUDUEUeDSUDeFdVEUUEUETDEVTSUTEDCTDED43TTT5TTdDEVU6TUUUUEEUTDUTUEEUT5ETEV4EEC5EDTUEBDUTTEETE4D5EUUTdDDETC%UTTC6U5TETEETETEUUUTEUTfUT4UEdeDUFUUeTTDCeVUFEdUD6UUEUUUDeEUEUEDUeEDSDDUESUdEeUTEUDee5EFUU4TUDED4UdUTTVFUFUTEDTVTDUUTUTDUDDEEE5UeTCE4UT544DS$TUETETU4TDUUDEVVTTUUUTSEVDdEd%UDBBTEUEUQUTTDE3UTE#DDS4S5TTUST#DTEE6DTTCTTS5DUET5d$TUUUDDCTUEDDVUSETTSC4VSET%cDTDCU3U5$TDST4fUUEDTET6UUTDUUDD4TTUUUUdTDTDEDTDdUSCCCTe$EERQUUTTTBUESTVTUUUDeTTTUUUDETEUUEUETDUTDE4UTE4C3R4TESDCU$UE4TCSSDT3UDTBEEDCEUEDCTESd2TTDT5TUEEUUSEeUDTD4TTTUTTTETSFUUEETTUSC4DdUD%U4TUdEdE4eVUVDUTUUeEdDEUedEE6EEEDSEDTUVUEEUVUUEDTEdFUUSDETDECS3DeUU%EDSESTTDCUbES6TSDUUDECUeUDTUDdTeTUUEETSUEU5TDCU4UE3TDRTCUEVETUUDSDSEDTdeUTUDeFUF4UEVTdUUUTTEUDd5DUDUETTeTUESEDUTETTVUEDET4STTUUEEDVTDUTTCfeETeTUUDUDEE