@cubingcenter/scrambler 0.5.3 → 0.6.0

package/dist/puzzles/fto/moves.js

@@ -0,0 +1,115 @@
+import { FTO_AXIS_MAP } from "./types.js";
+import { FtoCubie } from "./state.js";
+const moveU = new FtoCubie([1, 2, 0, 3, 4, 5], [0, 0, 0, 0, 0, 0], [2, 0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11], [1, 2, 0, 3, 4, 5, 6, 7, 8, 9, 10, 11], [0, 1, 2, 3, 6, 7, 11, 9, 8, 5, 10, 4]);
+const moveF = new FtoCubie([4, 1, 2, 3, 5, 0], [1, 0, 0, 0, 1, 0], [0, 1, 2, 3, 4, 6, 7, 5, 8, 9, 10, 11], [0, 1, 2, 4, 5, 3, 6, 7, 8, 9, 10, 11], [0, 9, 10, 3, 4, 5, 2, 7, 1, 8, 6, 11]);
+const moveBR = new FtoCubie([0, 5, 2, 1, 4, 3], [0, 1, 0, 0, 0, 1], [0, 1, 2, 3, 10, 5, 6, 7, 8, 9, 11, 4], [0, 1, 2, 3, 4, 5, 7, 8, 6, 9, 10, 11], [5, 3, 2, 11, 4, 10, 6, 7, 8, 9, 0, 1]);
+const moveBL = new FtoCubie([0, 1, 3, 4, 2, 5], [0, 0, 1, 1, 0, 0], [0, 1, 2, 8, 4, 5, 6, 7, 9, 3, 10, 11], [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 9], [8, 1, 7, 2, 0, 5, 6, 3, 4, 9, 10, 11]);
+const moveD = new FtoCubie([0, 1, 2, 5, 3, 4], [0, 0, 0, 0, 0, 0], [0, 1, 2, 4, 5, 3, 6, 7, 8, 9, 10, 11], [0, 1, 2, 3, 9, 10, 5, 7, 4, 8, 6, 11], [1, 2, 0, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
+const moveB = new FtoCubie([0, 3, 1, 2, 4, 5], [0, 1, 1, 0, 0, 0], [0, 1, 10, 3, 4, 5, 6, 7, 8, 2, 9, 11], [0, 6, 7, 3, 4, 5, 11, 9, 8, 2, 10, 1], [0, 1, 2, 4, 5, 3, 6, 7, 8, 9, 10, 11]);
+const moveR = new FtoCubie([5, 0, 2, 3, 4, 1], [1, 1, 0, 0, 0, 0], [6, 1, 2, 3, 4, 5, 11, 7, 8, 9, 10, 0], [5, 3, 2, 8, 4, 7, 6, 0, 1, 9, 10, 11], [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 9]);
+const moveL = new FtoCubie([2, 1, 4, 3, 0, 5], [1, 0, 1, 0, 0, 0], [0, 8, 2, 3, 4, 5, 6, 1, 7, 9, 10, 11], [11, 1, 10, 2, 0, 5, 6, 7, 8, 9, 3, 4], [0, 1, 2, 3, 4, 5, 7, 8, 6, 9, 10, 11]);
+export const FTO_MOVE_MAP = {
+    U: moveU,
+    "U'": FtoCubie.multiply(moveU, moveU),
+    F: moveF,
+    "F'": FtoCubie.multiply(moveF, moveF),
+    BR: moveBR,
+    "BR'": FtoCubie.multiply(moveBR, moveBR),
+    BL: moveBL,
+    "BL'": FtoCubie.multiply(moveBL, moveBL),
+    D: moveD,
+    "D'": FtoCubie.multiply(moveD, moveD),
+    B: moveB,
+    "B'": FtoCubie.multiply(moveB, moveB),
+    R: moveR,
+    "R'": FtoCubie.multiply(moveR, moveR),
+    L: moveL,
+    "L'": FtoCubie.multiply(moveL, moveL)
+};
+export function getFtoMoveFace(move) {
+    const base = move.replace(/'$/, "");
+    return base;
+}
+export function invertFtoMove(move) {
+    if (move.endsWith("'")) {
+        return move.slice(0, -1);
+    }
+    return `${move}'`;
+}
+export function invertFtoAlgorithm(moves) {
+    const inverted = new Array(moves.length);
+    for (let i = 0; i < moves.length; i++) {
+        inverted[moves.length - 1 - i] = invertFtoMove(moves[i]);
+    }
+    return inverted;
+}
+export function parseFtoAlgorithm(algorithm) {
+    const tokens = algorithm.trim().split(/\s+/).filter(Boolean);
+    const result = [];
+    for (const token of tokens) {
+        if (token in FTO_MOVE_MAP) {
+            result.push(token);
+        }
+        else {
+            throw new Error(`Invalid FTO move: ${token}`);
+        }
+    }
+    return result;
+}
+export function formatFtoAlgorithm(moves) {
+    return moves.join(" ");
+}
+export function applyFtoMove(state, move) {
+    const moveCubie = FTO_MOVE_MAP[move];
+    if (!moveCubie) {
+        throw new Error(`Unsupported FTO move: ${move}`);
+    }
+    return FtoCubie.multiply(state, moveCubie);
+}
+export function applyFtoAlgorithm(state, algorithm) {
+    const moves = typeof algorithm === "string" ? parseFtoAlgorithm(algorithm) : algorithm;
+    let current = state;
+    for (const move of moves) {
+        current = applyFtoMove(current, move);
+    }
+    return current;
+}
+const FTO_AXIS_ORDER = {
+    U: 0,
+    D: 1,
+    F: 0,
+    B: 1,
+    L: 0,
+    BR: 1,
+    R: 0,
+    BL: 1
+};
+export function isRedundantFtoMove(moves, newMove) {
+    if (moves.length === 0)
+        return false;
+    const newFace = getFtoMoveFace(newMove);
+    const newAxis = FTO_AXIS_MAP[newFace];
+    const lastMove = moves[moves.length - 1];
+    const lastFace = getFtoMoveFace(lastMove);
+    // No same face consecutively
+    if (lastFace === newFace)
+        return true;
+    const lastAxis = FTO_AXIS_MAP[lastFace];
+    // Different axis is always allowed
+    if (newAxis !== lastAxis)
+        return false;
+    // Same axis (commutes): enforce canonical order
+    // to avoid duplicates like [D, U] vs [U, D] and prevent sequences like [U, D, U]
+    if (moves.length >= 2) {
+        const prevMove = moves[moves.length - 2];
+        const prevFace = getFtoMoveFace(prevMove);
+        if (FTO_AXIS_MAP[prevFace] === newAxis) {
+            return true; // Already 2 moves on this axis in a row
+        }
+    }
+    // Canonical ordering for commuting faces on the same axis
+    if (FTO_AXIS_ORDER[newFace] <= FTO_AXIS_ORDER[lastFace]) {
+        return true;
+    }
+    return false;
+}

package/dist/puzzles/fto/random-state.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Uniform random-state generation for Face-Turning Octahedron (FTO).
+ *
+ * Samples uniformly from the 3.14 x 10^22 reachable states:
+ *  - Corner permutation in A_6 (360)
+ *  - Corner orientation in Z_2^5 with sum ≡ 0 (mod 2) (32)
+ *  - Edge permutation in A_12 (239,500,800)
+ *  - Orbit 1 centers (uf): multiset arrangement C(12,3)*C(9,3)*C(6,3) (369,600)
+ *  - Orbit 2 centers (rl): multiset arrangement C(12,3)*C(9,3)*C(6,3) (369,600)
+ */
+import type { FtoRandomStateOptions } from "./types.js";
+import { FtoCubie } from "./state.js";
+/**
+ * Generates a legal, uniformly-sampled random FTO state.
+ */
+export declare function generateRandomFtoState(options?: FtoRandomStateOptions): FtoCubie;
+//# sourceMappingURL=random-state.d.ts.map

package/dist/puzzles/fto/random-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/fto/random-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAWH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAQtC;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,qBAA0B,GAAG,QAAQ,CA2BpF"}

package/dist/puzzles/fto/random-state.js

@@ -0,0 +1,40 @@
+/**
+ * Uniform random-state generation for Face-Turning Octahedron (FTO).
+ *
+ * Samples uniformly from the 3.14 x 10^22 reachable states:
+ *  - Corner permutation in A_6 (360)
+ *  - Corner orientation in Z_2^5 with sum ≡ 0 (mod 2) (32)
+ *  - Edge permutation in A_12 (239,500,800)
+ *  - Orbit 1 centers (uf): multiset arrangement C(12,3)*C(9,3)*C(6,3) (369,600)
+ *  - Orbit 2 centers (rl): multiset arrangement C(12,3)*C(9,3)*C(6,3) (369,600)
+ */
+import { createRandomSource } from "../../random/index.js";
+import { FTO_CENTER_ORBIT_STATES, FTO_CORNER_COUNT, FTO_CORNER_ORI_STATES, FTO_CORNER_PERM_STATES, FTO_EDGE_COUNT, FTO_EDGE_PERM_STATES } from "./types.js";
+import { FtoCubie } from "./state.js";
+import { unpackCenterOrbit, unpackCornerOrientation, unpackEvenPerm } from "./coordinates.js";
+import { isTrivialFtoState } from "./validation.js";
+/**
+ * Generates a legal, uniformly-sampled random FTO state.
+ */
+export function generateRandomFtoState(options = {}) {
+    const random = createRandomSource(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const cpRank = random.nextInt(FTO_CORNER_PERM_STATES);
+        const coRank = random.nextInt(FTO_CORNER_ORI_STATES);
+        const epRank = random.nextInt(FTO_EDGE_PERM_STATES);
+        const ufRank = random.nextInt(FTO_CENTER_ORBIT_STATES);
+        const rlRank = random.nextInt(FTO_CENTER_ORBIT_STATES);
+        const cp = unpackEvenPerm(FTO_CORNER_COUNT, cpRank);
+        const co = unpackCornerOrientation(coRank);
+        const ep = unpackEvenPerm(FTO_EDGE_COUNT, epRank);
+        const uf = unpackCenterOrbit(ufRank);
+        const rl = unpackCenterOrbit(rlRank);
+        const state = new FtoCubie(cp, co, ep, uf, rl);
+        if (rejectTrivial && isTrivialFtoState(state)) {
+            continue;
+        }
+        return state;
+    }
+    throw new Error("Unable to generate a non-trivial random FTO state.");
+}

package/dist/puzzles/fto/scrambler.d.ts

@@ -0,0 +1,6 @@
+import type { ScrambleGenerator, ScrambleOptions, ScrambleResult } from "../../core/index.js";
+export declare const ftoScrambleGenerator: ScrambleGenerator;
+export declare function generateFtoScramble(options?: ScrambleOptions & {
+    skipValidation?: boolean;
+}): ScrambleResult;
+//# sourceMappingURL=scrambler.d.ts.map

package/dist/puzzles/fto/scrambler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/fto/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,cAAc,EACf,MAAM,qBAAqB,CAAC;AAU7B,eAAO,MAAM,oBAAoB,EAAE,iBAalC,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,OAAO,GAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,cAAc,CAuChB"}

package/dist/puzzles/fto/scrambler.js

@@ -0,0 +1,49 @@
+import { createRandomSource } from "../../random/index.js";
+import { applyFtoAlgorithm, invertFtoAlgorithm } from "./moves.js";
+import { createSolvedFtoState } from "./state.js";
+import { formatFtoFacelets } from "./facelets.js";
+import { generateFtoRandomState } from "./solver/index.js";
+export const ftoScrambleGenerator = {
+    info: {
+        eventId: "fto",
+        name: "Face-Turning Octahedron",
+        puzzle: "fto",
+        quality: "random-state",
+        generator: "fto-three-phase",
+        description: "Random-state Face-Turning Octahedron scramble generated by a 3-phase reduction solver."
+    },
+    generate(options = {}) {
+        return generateFtoScramble(options);
+    }
+};
+export function generateFtoScramble(options = {}) {
+    const random = createRandomSource(options.seed);
+    const { scramble, moves, state, facelets } = generateFtoRandomState(() => random.next());
+    if (!options.skipValidation) {
+        const replayed = applyFtoAlgorithm(createSolvedFtoState(), moves);
+        if (!replayed.isEqual(state)) {
+            throw new Error("Generated FTO scramble does not reproduce the target random state.");
+        }
+    }
+    const solutionMoves = invertFtoAlgorithm(moves);
+    const faceletString = formatFtoFacelets(facelets);
+    const result = {
+        eventId: "fto",
+        scramble,
+        moves,
+        quality: "random-state",
+        generator: "fto-three-phase",
+        metadata: {
+            totalMoves: moves.length,
+            solutionDepth: solutionMoves.length,
+            solutionMoves,
+            state,
+            facelets,
+            faceletString
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}

package/dist/puzzles/fto/solver/engine.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Face-Turning Octahedron (FTO) 3-Phase Random-State Solver & Scrambler Engine.
+ * Adapted from cs0x7f / Shuang Chen reference implementation under MIT License.
+ */
+import { FtoCubie } from "../state.js";
+import { toFtoFacelets } from "../facelets.js";
+import type { FtoMove } from "../types.js";
+export declare function initFtoSolver(): void;
+export declare function isFtoSolverInitialized(): boolean;
+export declare function solveFtoFacelet(facelet: readonly number[], invSol?: boolean): string;
+export declare function solveFto(fc: FtoCubie): FtoMove[];
+export declare function generateFtoRandomState(rng?: () => number): {
+    scramble: string;
+    moves: FtoMove[];
+    state: FtoCubie;
+    facelets: ReturnType<typeof toFtoFacelets>;
+};
+//# sourceMappingURL=engine.d.ts.map

package/dist/puzzles/fto/solver/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/fto/solver/engine.ts"],"names":[],"mappings":"AACA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AA2rC3C,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAED,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,UAAQ,GAAG,MAAM,CAElF;AAED,wBAAgB,QAAQ,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,EAAE,CAIhD;AAED,wBAAgB,sBAAsB,CAAC,GAAG,GAAE,MAAM,MAAoB,GAAG;IACvE,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,KAAK,EAAE,QAAQ,CAAC;IAChB,QAAQ,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;CAC5C,CAYA"}