cubegin 0.0.1

package/dist/scramble-core/src/generators/three-by-three.mjs

@@ -0,0 +1,85 @@
+import { axisForRestriction, splitAlgorithm } from "../solvers/min2phase/util.mjs";
+import { SearchWCA } from "../solvers/min2phase/search-wca.mjs";
+import { randomCube } from "../solvers/min2phase/tools.mjs";
+//#region .build/vendor/scramble-core/src/generators/three-by-three.ts
+const THREE_BY_THREE_MAX_SCRAMBLE_LENGTH = 21;
+const THREE_BY_THREE_PROBE_MAX = 1e5;
+const THREE_BY_THREE_PROBE_MIN = 0;
+const THREE_BY_THREE_MAX_ATTEMPTS = 20;
+const FMC_PADDING = "R' U' F";
+const ORIENTATION_SEQUENCES = [
+	[],
+	["Uw"],
+	["Uw2"],
+	["Uw'"],
+	["Rw"],
+	["Rw", "Uw"],
+	["Rw", "Uw2"],
+	["Rw", "Uw'"],
+	["Rw2"],
+	["Rw2", "Uw"],
+	["Rw2", "Uw2"],
+	["Rw2", "Uw'"],
+	["Rw'"],
+	["Rw'", "Uw"],
+	["Rw'", "Uw2"],
+	["Rw'", "Uw'"],
+	["Fw"],
+	["Fw", "Uw"],
+	["Fw", "Uw2"],
+	["Fw", "Uw'"],
+	["Fw'"],
+	["Fw'", "Uw"],
+	["Fw'", "Uw2"],
+	["Fw'", "Uw'"]
+];
+const generateThreeByThreeScramble = ({ random }) => generateInverseSolution({ random });
+const generateThreeByThreeNoInspectionScramble = ({ random }) => {
+	const orientation = chooseOrientation(random);
+	return [...splitAlgorithm(generateInverseSolution({
+		random,
+		lastAxisRestriction: orientation[0]?.[0] ?? null
+	})), ...orientation].join(" ");
+};
+const generateThreeByThreeFewestMovesScramble = ({ random }) => {
+	return `${FMC_PADDING} ${generateInverseSolution({
+		random,
+		firstAxisRestriction: "F",
+		lastAxisRestriction: "R"
+	})} ${FMC_PADDING}`;
+};
+const generateMultiBlindScramble = ({ random, cubeCount }) => {
+	validateCubeCount(cubeCount);
+	return Array.from({ length: cubeCount }, () => generateThreeByThreeNoInspectionScramble({ random })).join("\n");
+};
+const generateInverseSolution = ({ random, firstAxisRestriction, lastAxisRestriction }) => {
+	const search = new SearchWCA();
+	for (let attempt = 0; attempt < THREE_BY_THREE_MAX_ATTEMPTS; attempt += 1) {
+		const solution = search.solution(randomCube(random), THREE_BY_THREE_MAX_SCRAMBLE_LENGTH, THREE_BY_THREE_PROBE_MAX, THREE_BY_THREE_PROBE_MIN, 2, firstAxisRestriction, lastAxisRestriction).trim();
+		if (!solution.startsWith("Error")) {
+			if (satisfiesAxisRestrictions(solution, firstAxisRestriction, lastAxisRestriction)) return solution;
+			continue;
+		}
+		if (solution !== "Error 7" && solution !== "Error 8") throw new Error(`@cubegin/scramble-core: min2phase returned ${solution}`);
+	}
+	throw new Error("@cubegin/scramble-core: min2phase could not find a 3x3 scramble within retry limit");
+};
+const satisfiesAxisRestrictions = (scramble, firstAxisRestriction, lastAxisRestriction) => {
+	const moves = splitAlgorithm(scramble);
+	return !violatesAxisRestriction(moves[0], firstAxisRestriction) && !violatesAxisRestriction(moves.at(-1), lastAxisRestriction);
+};
+const violatesAxisRestriction = (move, restriction) => {
+	if (move === void 0 || restriction === null || restriction === void 0) return false;
+	return axisForRestriction(move[0]) === axisForRestriction(restriction);
+};
+const chooseOrientation = (random) => {
+	const index = random.nextInt(ORIENTATION_SEQUENCES.length);
+	const orientation = ORIENTATION_SEQUENCES[index];
+	if (orientation === void 0) throw new RangeError(`@cubegin/scramble-core: random source returned ${index} for max ${ORIENTATION_SEQUENCES.length}`);
+	return orientation;
+};
+const validateCubeCount = (cubeCount) => {
+	if (!Number.isSafeInteger(cubeCount) || cubeCount <= 0) throw new Error("@cubegin/scramble-core: multi-blind cubeCount must be a positive safe integer");
+};
+//#endregion
+export { generateMultiBlindScramble, generateThreeByThreeFewestMovesScramble, generateThreeByThreeNoInspectionScramble, generateThreeByThreeScramble };

package/dist/scramble-core/src/generators/two-by-two.d.mts

@@ -0,0 +1,11 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/generators/two-by-two.d.ts
+interface TwoByTwoScrambleOptions {
+  random: RandomSource;
+}
+declare const generateTwoByTwoScramble: ({
+  random
+}: TwoByTwoScrambleOptions) => string;
+//#endregion
+export { TwoByTwoScrambleOptions, generateTwoByTwoScramble };

package/dist/scramble-core/src/generators/two-by-two.mjs

@@ -0,0 +1,17 @@
+import { TwoByTwoSolver } from "../solvers/two-by-two-solver.mjs";
+//#region .build/vendor/scramble-core/src/generators/two-by-two.ts
+const ERROR_PREFIX = "@cubegin/scramble-core";
+const SCRAMBLE_LENGTH = 11;
+const WCA_MIN_SCRAMBLE_DISTANCE = 4;
+const MAX_WCA_ATTEMPTS = 100;
+const generateTwoByTwoScramble = ({ random }) => {
+	const solver = new TwoByTwoSolver();
+	for (let attempt = 0; attempt < MAX_WCA_ATTEMPTS; attempt += 1) {
+		const state = solver.randomState(random);
+		if (solver.solveIn(state, WCA_MIN_SCRAMBLE_DISTANCE - 1) !== null) continue;
+		return solver.generateExactly(state, SCRAMBLE_LENGTH);
+	}
+	throw new Error(`${ERROR_PREFIX}: could not generate a 2x2 WCA scramble after ${MAX_WCA_ATTEMPTS} attempts`);
+};
+//#endregion
+export { generateTwoByTwoScramble };

package/dist/scramble-core/src/random-source.d.mts

@@ -0,0 +1,7 @@
+//#region .build/vendor/scramble-core/src/random-source.d.ts
+interface RandomSource {
+  nextInt(maxExclusive: number): number;
+}
+declare const createMathRandomSource: () => RandomSource;
+//#endregion
+export { RandomSource, createMathRandomSource };

package/dist/scramble-core/src/random-source.mjs

@@ -0,0 +1,8 @@
+//#region .build/vendor/scramble-core/src/random-source.ts
+const ERROR_PREFIX = "@cubegin/scramble-core";
+const createMathRandomSource = () => ({ nextInt(maxExclusive) {
+	if (!Number.isSafeInteger(maxExclusive) || maxExclusive <= 0) throw new Error(`${ERROR_PREFIX}: random maxExclusive must be a positive safe integer`);
+	return Math.floor(Math.random() * maxExclusive);
+} });
+//#endregion
+export { createMathRandomSource };

package/dist/scramble-core/src/solvers/min2phase/coord-cube.mjs

@@ -0,0 +1,10 @@
+import { initialize } from "./engine.mjs";
+//#region .build/vendor/scramble-core/src/solvers/min2phase/coord-cube.ts
+let isInitialized = false;
+const initCoordCube = () => {
+	if (isInitialized) return;
+	initialize();
+	isInitialized = true;
+};
+//#endregion
+export { initCoordCube };

package/dist/scramble-core/src/solvers/min2phase/cubie-cube.mjs

@@ -0,0 +1,246 @@
+import { SOLVED_FACE_CUBE } from "./util.mjs";
+//#region .build/vendor/scramble-core/src/solvers/min2phase/cubie-cube.ts
+const CORNER_FACELET = [
+	[
+		8,
+		9,
+		20
+	],
+	[
+		6,
+		18,
+		38
+	],
+	[
+		0,
+		36,
+		47
+	],
+	[
+		2,
+		45,
+		11
+	],
+	[
+		29,
+		26,
+		15
+	],
+	[
+		27,
+		44,
+		24
+	],
+	[
+		33,
+		53,
+		42
+	],
+	[
+		35,
+		17,
+		51
+	]
+];
+const EDGE_FACELET = [
+	[5, 10],
+	[7, 19],
+	[3, 37],
+	[1, 46],
+	[32, 16],
+	[28, 25],
+	[30, 43],
+	[34, 52],
+	[23, 12],
+	[21, 41],
+	[50, 39],
+	[48, 14]
+];
+const FACE_NAMES = [
+	"U",
+	"R",
+	"F",
+	"D",
+	"L",
+	"B"
+];
+var CubieCube = class CubieCube {
+	cp;
+	co;
+	ep;
+	eo;
+	constructor(cp = [
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7
+	], co = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	], ep = [
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		10,
+		11
+	], eo = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	]) {
+		this.cp = [...cp];
+		this.co = [...co];
+		this.ep = [...ep];
+		this.eo = [...eo];
+	}
+	static solved() {
+		return new CubieCube();
+	}
+	static fromCoordinates(cperm, twist, eperm, flip) {
+		const cube = new CubieCube();
+		setNPerm(cube.cp, cperm, 8);
+		setTwist(cube.co, twist);
+		setNPerm(cube.ep, eperm, 12);
+		setFlip(cube.eo, flip);
+		return cube;
+	}
+	static fromFaceCube(facelets) {
+		if (facelets.length !== 54) return null;
+		const centerColors = [
+			facelets[4],
+			facelets[13],
+			facelets[22],
+			facelets[31],
+			facelets[40],
+			facelets[49]
+		];
+		const colors = Array.from(facelets, (facelet) => centerColors.indexOf(facelet));
+		if (colors.some((color) => color < 0)) return null;
+		const cp = Array(8).fill(0);
+		const co = Array(8).fill(0);
+		const ep = Array(12).fill(0);
+		const eo = Array(12).fill(0);
+		for (let corner = 0; corner < 8; corner += 1) {
+			let orientation = 0;
+			while (orientation < 3 && colors[CORNER_FACELET[corner][orientation]] !== 0 && colors[CORNER_FACELET[corner][orientation]] !== 3) orientation += 1;
+			if (orientation === 3) return null;
+			const color1 = colors[CORNER_FACELET[corner][(orientation + 1) % 3]];
+			const color2 = colors[CORNER_FACELET[corner][(orientation + 2) % 3]];
+			const cubie = CORNER_FACELET.findIndex(([, facelet1, facelet2]) => color1 === Math.floor(facelet1 / 9) && color2 === Math.floor(facelet2 / 9));
+			if (cubie < 0) return null;
+			cp[corner] = cubie;
+			co[corner] = orientation % 3;
+		}
+		for (let edge = 0; edge < 12; edge += 1) {
+			const color0 = colors[EDGE_FACELET[edge][0]];
+			const color1 = colors[EDGE_FACELET[edge][1]];
+			const cubie = EDGE_FACELET.findIndex(([facelet0, facelet1]) => color0 === Math.floor(facelet0 / 9) && color1 === Math.floor(facelet1 / 9));
+			if (cubie >= 0) {
+				ep[edge] = cubie;
+				eo[edge] = 0;
+				continue;
+			}
+			const flippedCubie = EDGE_FACELET.findIndex(([facelet0, facelet1]) => color0 === Math.floor(facelet1 / 9) && color1 === Math.floor(facelet0 / 9));
+			if (flippedCubie < 0) return null;
+			ep[edge] = flippedCubie;
+			eo[edge] = 1;
+		}
+		return new CubieCube(cp, co, ep, eo);
+	}
+	toFaceCube() {
+		const facelets = Array.from(SOLVED_FACE_CUBE);
+		for (let corner = 0; corner < 8; corner += 1) {
+			const cubie = this.cp[corner];
+			const orientation = this.co[corner];
+			for (let index = 0; index < 3; index += 1) facelets[CORNER_FACELET[corner][(index + orientation) % 3]] = FACE_NAMES[Math.floor(CORNER_FACELET[cubie][index] / 9)] ?? "U";
+		}
+		for (let edge = 0; edge < 12; edge += 1) {
+			const cubie = this.ep[edge];
+			const orientation = this.eo[edge];
+			for (let index = 0; index < 2; index += 1) facelets[EDGE_FACELET[edge][(index + orientation) % 2]] = FACE_NAMES[Math.floor(EDGE_FACELET[cubie][index] / 9)] ?? "U";
+		}
+		return facelets.join("");
+	}
+	verify() {
+		if (this.ep.reduce((mask, edge) => mask | 1 << edge, 0) !== 4095) return -2;
+		if (this.eo.reduce((sum, orientation) => sum ^ orientation, 0) !== 0) return -3;
+		if (this.cp.reduce((mask, corner) => mask | 1 << corner, 0) !== 255) return -4;
+		if (this.co.reduce((sum, orientation) => sum + orientation, 0) % 3 !== 0) return -5;
+		if ((getNParity(getNPerm(this.ep, 12), 12) ^ getNParity(getNPerm(this.cp, 8), 8)) !== 0) return -6;
+		return 0;
+	}
+};
+const getNParity = (index, n) => {
+	let parity = 0;
+	let value = index;
+	for (let current = n - 2; current >= 0; current -= 1) {
+		parity ^= value % (n - current);
+		value = Math.floor(value / (n - current));
+	}
+	return parity & 1;
+};
+const getNPerm = (permutation, n) => {
+	let index = 0;
+	for (let i = 0; i < n; i += 1) {
+		index *= n - i;
+		for (let j = i + 1; j < n; j += 1) if ((permutation[j] ?? 0) < (permutation[i] ?? 0)) index += 1;
+	}
+	return index;
+};
+const setNPerm = (permutation, index, n) => {
+	for (let i = n - 1; i >= 0; i -= 1) {
+		permutation[i] = index % (n - i);
+		index = Math.floor(index / (n - i));
+		for (let j = i + 1; j < n; j += 1) if ((permutation[j] ?? 0) >= (permutation[i] ?? 0)) permutation[j] = (permutation[j] ?? 0) + 1;
+	}
+};
+const setTwist = (orientations, index) => {
+	let twist = 0;
+	let value = index;
+	for (let i = 6; i >= 0; i -= 1) {
+		const orientation = value % 3;
+		orientations[i] = orientation;
+		twist += orientation;
+		value = Math.floor(value / 3);
+	}
+	orientations[7] = (15 - twist) % 3;
+};
+const setFlip = (orientations, index) => {
+	let parity = 0;
+	let value = index;
+	for (let i = 10; i >= 0; i -= 1) {
+		const orientation = value & 1;
+		orientations[i] = orientation;
+		parity ^= orientation;
+		value >>= 1;
+	}
+	orientations[11] = parity;
+};
+//#endregion
+export { CubieCube, getNParity, getNPerm };