cubegin 0.0.1

package/dist/scramble-core/src/solvers/skewb-solver.mjs

@@ -0,0 +1,399 @@
+//#region .build/vendor/scramble-core/src/solvers/skewb-solver.ts
+const ERROR_PREFIX = "@cubegin/scramble-core";
+const N_MOVES = 4;
+const N_PERM = 4320;
+const N_TWIST = 2187;
+const MAX_SOLUTION_LENGTH = 12;
+const MAX_TWIST_ATTEMPTS = 100;
+const FACT = [
+	1,
+	1,
+	1,
+	3,
+	12,
+	60,
+	360
+];
+const CORNER_PERM_MOVES = [
+	[
+		6,
+		5,
+		10,
+		1
+	],
+	[
+		9,
+		7,
+		4,
+		2
+	],
+	[
+		3,
+		11,
+		8,
+		0
+	],
+	[
+		10,
+		1,
+		6,
+		5
+	],
+	[
+		0,
+		8,
+		11,
+		3
+	],
+	[
+		7,
+		9,
+		2,
+		4
+	],
+	[
+		4,
+		2,
+		9,
+		7
+	],
+	[
+		11,
+		3,
+		0,
+		8
+	],
+	[
+		1,
+		10,
+		5,
+		6
+	],
+	[
+		8,
+		0,
+		3,
+		11
+	],
+	[
+		2,
+		4,
+		7,
+		9
+	],
+	[
+		5,
+		6,
+		1,
+		10
+	]
+];
+const ORIENTATION_BY_CORNER = [
+	0,
+	1,
+	2,
+	0,
+	2,
+	1,
+	1,
+	2,
+	0,
+	2,
+	1,
+	0
+];
+const SOLUTION_MOVES = [
+	"L",
+	"R",
+	"B",
+	"U"
+];
+let cachedTables;
+const createAvailableCenters = () => [
+	0,
+	1,
+	2,
+	3,
+	4,
+	5
+];
+const unpackCenterPerm = (centerIndex) => {
+	let remaining = centerIndex;
+	let parity = 0;
+	const available = createAvailableCenters();
+	const centerPerm = Array.from({ length: 6 }, () => 0);
+	for (let position = 0; position < 5; position += 1) {
+		const divisor = FACT[5 - position];
+		const selectedIndex = Math.floor(remaining / divisor);
+		remaining -= selectedIndex * divisor;
+		parity ^= selectedIndex;
+		centerPerm[position] = available.splice(selectedIndex, 1)[0];
+	}
+	if ((parity & 1) === 0) centerPerm[5] = available[0];
+	else {
+		centerPerm[5] = centerPerm[4];
+		centerPerm[4] = available[0];
+	}
+	return centerPerm;
+};
+const packCenterPerm = (centerPerm) => {
+	const available = createAvailableCenters();
+	let centerIndex = 0;
+	for (let position = 0; position < 4; position += 1) {
+		const selectedIndex = available.indexOf(centerPerm[position]);
+		centerIndex *= 6 - position;
+		centerIndex += selectedIndex;
+		available.splice(selectedIndex, 1);
+	}
+	return centerIndex;
+};
+const moveCenterPerm = (centerPerm, move) => {
+	let savedCenter;
+	switch (move) {
+		case 0:
+			savedCenter = centerPerm[0];
+			centerPerm[0] = centerPerm[1];
+			centerPerm[1] = centerPerm[3];
+			centerPerm[3] = savedCenter;
+			break;
+		case 1:
+			savedCenter = centerPerm[0];
+			centerPerm[0] = centerPerm[4];
+			centerPerm[4] = centerPerm[2];
+			centerPerm[2] = savedCenter;
+			break;
+		case 2:
+			savedCenter = centerPerm[1];
+			centerPerm[1] = centerPerm[2];
+			centerPerm[2] = centerPerm[5];
+			centerPerm[5] = savedCenter;
+			break;
+		case 3:
+			savedCenter = centerPerm[3];
+			centerPerm[3] = centerPerm[5];
+			centerPerm[5] = centerPerm[4];
+			centerPerm[4] = savedCenter;
+			break;
+	}
+};
+const getPermMove = (index, move) => {
+	const centerPerm = unpackCenterPerm(Math.floor(index / 12));
+	const cornerIndex = index % 12;
+	moveCenterPerm(centerPerm, move);
+	return packCenterPerm(centerPerm) * 12 + CORNER_PERM_MOVES[cornerIndex][move];
+};
+const getTwistMove = (index, move) => {
+	const fixedTwist = Array.from({ length: 4 }, () => 0);
+	const twist = Array.from({ length: 4 }, () => 0);
+	let remaining = index;
+	for (let position = 0; position < 4; position += 1) {
+		fixedTwist[position] = remaining % 3;
+		remaining = Math.floor(remaining / 3);
+	}
+	for (let position = 0; position < 3; position += 1) {
+		twist[position] = remaining % 3;
+		remaining = Math.floor(remaining / 3);
+	}
+	twist[3] = (6 - twist[0] - twist[1] - twist[2]) % 3;
+	fixedTwist[move] = (fixedTwist[move] + 1) % 3;
+	let savedTwist;
+	switch (move) {
+		case 0:
+			savedTwist = twist[0];
+			twist[0] = twist[2] + 2;
+			twist[2] = twist[1] + 2;
+			twist[1] = savedTwist + 2;
+			break;
+		case 1:
+			savedTwist = twist[0];
+			twist[0] = twist[1] + 2;
+			twist[1] = twist[3] + 2;
+			twist[3] = savedTwist + 2;
+			break;
+		case 2:
+			savedTwist = twist[0];
+			twist[0] = twist[3] + 2;
+			twist[3] = twist[2] + 2;
+			twist[2] = savedTwist + 2;
+			break;
+		case 3:
+			savedTwist = twist[1];
+			twist[1] = twist[2] + 2;
+			twist[2] = twist[3] + 2;
+			twist[3] = savedTwist + 2;
+			break;
+	}
+	for (let position = 2; position >= 0; position -= 1) remaining = remaining * 3 + twist[position] % 3;
+	for (let position = 3; position >= 0; position -= 1) remaining = remaining * 3 + fixedTwist[position];
+	return remaining;
+};
+const createMoveTables = () => {
+	const movePerm = Array.from({ length: N_PERM }, () => new Uint16Array(N_MOVES));
+	const moveTwist = Array.from({ length: N_TWIST }, () => new Uint16Array(N_MOVES));
+	for (let permutation = 0; permutation < N_PERM; permutation += 1) for (let move = 0; move < N_MOVES; move += 1) movePerm[permutation][move] = getPermMove(permutation, move);
+	for (let twist = 0; twist < N_TWIST; twist += 1) for (let move = 0; move < N_MOVES; move += 1) moveTwist[twist][move] = getTwistMove(twist, move);
+	return {
+		movePerm,
+		moveTwist
+	};
+};
+const createPermutationPruningTable = (movePerm) => {
+	const pruning = new Int8Array(N_PERM);
+	pruning.fill(-1);
+	pruning[0] = 0;
+	for (let length = 0; length < 6; length += 1) for (let permutation = 0; permutation < N_PERM; permutation += 1) {
+		if (pruning[permutation] !== length) continue;
+		for (let move = 0; move < N_MOVES; move += 1) {
+			let nextPermutation = permutation;
+			for (let count = 0; count < 2; count += 1) {
+				nextPermutation = movePerm[nextPermutation][move];
+				if (pruning[nextPermutation] !== -1) continue;
+				pruning[nextPermutation] = length + 1;
+			}
+		}
+	}
+	return pruning;
+};
+const createTwistPruningTable = (moveTwist) => {
+	const pruning = new Int8Array(N_TWIST);
+	pruning.fill(-1);
+	pruning[0] = 0;
+	for (let length = 0; length < 6; length += 1) for (let twist = 0; twist < N_TWIST; twist += 1) {
+		if (pruning[twist] !== length) continue;
+		for (let move = 0; move < N_MOVES; move += 1) {
+			let nextTwist = twist;
+			for (let count = 0; count < 2; count += 1) {
+				nextTwist = moveTwist[nextTwist][move];
+				if (pruning[nextTwist] !== -1) continue;
+				pruning[nextTwist] = length + 1;
+			}
+		}
+	}
+	return pruning;
+};
+const createTables = () => {
+	const { movePerm, moveTwist } = createMoveTables();
+	return {
+		movePerm,
+		moveTwist,
+		prunPerm: createPermutationPruningTable(movePerm),
+		prunTwist: createTwistPruningTable(moveTwist)
+	};
+};
+const getTables = () => {
+	cachedTables ??= createTables();
+	return cachedTables;
+};
+const validateCoordinate = (coordinateName, coordinate, maxExclusive) => {
+	if (!Number.isSafeInteger(coordinate) || coordinate < 0 || coordinate >= maxExclusive) throw new RangeError(`${ERROR_PREFIX}: Skewb ${coordinateName} must be an integer from 0 to ${maxExclusive - 1}`);
+};
+const validateState = (state) => {
+	validateCoordinate("perm", state.perm, N_PERM);
+	validateCoordinate("twst", state.twst, N_TWIST);
+};
+const validateLength = (length) => {
+	if (!Number.isSafeInteger(length) || length < 0 || length > MAX_SOLUTION_LENGTH) throw new RangeError(`${ERROR_PREFIX}: Skewb solve length must be an integer from 0 to ${MAX_SOLUTION_LENGTH}`);
+};
+const nextCoordinate = (random, coordinateName, maxExclusive) => {
+	const coordinate = random.nextInt(maxExclusive);
+	validateCoordinate(coordinateName, coordinate, maxExclusive);
+	return coordinate;
+};
+const isSolvable = (state) => ORIENTATION_BY_CORNER[state.perm % 12] === (state.twst + Math.floor(state.twst / 3) + Math.floor(state.twst / 9) + Math.floor(state.twst / 27)) % 3;
+const search = ({ perm, twst, depth, length, lastMove, solution, random, tables }) => {
+	if (length === 0) return perm === 0 && twst === 0 ? depth : -1;
+	if (tables.prunPerm[perm] > length || tables.prunTwist[twst] > length) return -1;
+	const randomOffset = nextCoordinate(random, "searchMoveOffset", N_MOVES);
+	for (let move = 0; move < N_MOVES; move += 1) {
+		const randomMove = (move + randomOffset) % N_MOVES;
+		if (randomMove === lastMove) continue;
+		let nextPerm = perm;
+		let nextTwist = twst;
+		for (let amount = 0; amount < 2; amount += 1) {
+			nextPerm = tables.movePerm[nextPerm][randomMove];
+			nextTwist = tables.moveTwist[nextTwist][randomMove];
+			const searchResult = search({
+				perm: nextPerm,
+				twst: nextTwist,
+				depth: depth + 1,
+				length: length - 1,
+				lastMove: randomMove,
+				solution,
+				random,
+				tables
+			});
+			if (searchResult !== -1) {
+				solution[depth] = randomMove * 2 + amount;
+				return searchResult;
+			}
+		}
+	}
+	return -1;
+};
+const swapMoveNames = (moveNames) => {
+	const savedMove = moveNames[0];
+	moveNames[0] = moveNames[1];
+	moveNames[1] = moveNames[3];
+	moveNames[3] = savedMove;
+};
+const formatSolution = (solution, solutionLength) => {
+	const moves = [];
+	const moveNames = [...SOLUTION_MOVES];
+	for (let index = 0; index < solutionLength; index += 1) {
+		const axis = solution[index] >> 1;
+		const power = solution[index] & 1;
+		if (axis === 2) for (let count = 0; count <= power; count += 1) swapMoveNames(moveNames);
+		moves.push(`${moveNames[axis]}${power === 1 ? "'" : ""}`);
+	}
+	return moves.join(" ");
+};
+var SkewbSolver = class {
+	randomState(random) {
+		const state = {
+			perm: nextCoordinate(random, "perm", N_PERM),
+			twst: 0
+		};
+		for (let attempt = 0; attempt < MAX_TWIST_ATTEMPTS; attempt += 1) {
+			const sampledTwist = nextCoordinate(random, "twst", N_TWIST);
+			const sampledState = {
+				...state,
+				twst: sampledTwist
+			};
+			if (!isSolvable(sampledState)) continue;
+			return sampledState;
+		}
+		throw new Error(`${ERROR_PREFIX}: could not sample a solvable Skewb twist after ${MAX_TWIST_ATTEMPTS} attempts`);
+	}
+	solveIn(state, length, random) {
+		return this.solve(state, length, false, random);
+	}
+	generateExactly(state, length, random) {
+		const scramble = this.solve(state, length, true, random);
+		if (scramble === null) throw new Error(`${ERROR_PREFIX}: could not generate a Skewb scramble exactly ${length} moves long`);
+		return scramble;
+	}
+	solve(state, desiredLength, exactLength, random) {
+		validateState(state);
+		validateLength(desiredLength);
+		const solution = Array.from({ length: MAX_SOLUTION_LENGTH }, () => 0);
+		const tables = getTables();
+		let length = exactLength ? desiredLength : 0;
+		while (length <= desiredLength) {
+			const solutionLength = search({
+				perm: state.perm,
+				twst: state.twst,
+				depth: 0,
+				length,
+				lastMove: -1,
+				solution,
+				random,
+				tables
+			});
+			if (solutionLength !== -1) return formatSolution(solution, solutionLength);
+			length += 1;
+		}
+		return null;
+	}
+};
+//#endregion
+export { SkewbSolver };

package/dist/scramble-core/src/solvers/sq12phase/full-cube.mjs

@@ -0,0 +1,212 @@
+import { getShape2Idx, getShapeTables } from "./shape.mjs";
+import { createSquareCoordinate, get8Perm } from "./square.mjs";
+//#region .build/vendor/scramble-core/src/solvers/sq12phase/full-cube.ts
+const ERROR_PREFIX = "@cubegin/scramble-core";
+const SOLVED_UL = 70195;
+const SOLVED_UR = 4544119;
+const SOLVED_DL = 10062778;
+const SOLVED_DR = 14536702;
+const FACE_MASK = 16777215;
+const SQUARE_ONE_TO_FULL_CUBE_PIECE = [
+	3,
+	2,
+	1,
+	0,
+	7,
+	6,
+	5,
+	4,
+	10,
+	11,
+	8,
+	9,
+	14,
+	15,
+	12,
+	13
+];
+const SQUARE_ONE_TO_FULL_CUBE_POSITION = [
+	5,
+	4,
+	3,
+	2,
+	1,
+	0,
+	11,
+	10,
+	9,
+	8,
+	7,
+	6,
+	17,
+	16,
+	15,
+	14,
+	13,
+	12,
+	23,
+	22,
+	21,
+	20,
+	19,
+	18
+];
+var FullCube = class FullCube {
+	permutationScratch = Array.from({ length: 8 }, () => 0);
+	parityScratch = Array.from({ length: 16 }, () => 0);
+	ul = SOLVED_UL;
+	ur = SOLVED_UR;
+	dl = SOLVED_DL;
+	dr = SOLVED_DR;
+	ml = 0;
+	static randomCube(random) {
+		const { shapeIdx } = getShapeTables();
+		const shape = shapeIdx[drawRandomInt(random, 3678)];
+		const cube = new FullCube();
+		let corners = 324508639;
+		let edges = 38177486;
+		let remainingCorners = 8;
+		let remainingEdges = 8;
+		for (let index = 0; index < 24; index += 1) if ((shape >> index & 1) === 0) {
+			const randomEdge = drawRandomInt(random, remainingEdges) << 2;
+			cube.setPiece(23 - index, edges >> randomEdge & 15);
+			edges = removeNibble(edges, randomEdge);
+			remainingEdges -= 1;
+		} else {
+			const randomCorner = drawRandomInt(random, remainingCorners) << 2;
+			const corner = corners >> randomCorner & 15;
+			cube.setPiece(23 - index, corner);
+			cube.setPiece(22 - index, corner);
+			corners = removeNibble(corners, randomCorner);
+			remainingCorners -= 1;
+			index += 1;
+		}
+		cube.ml = drawRandomInt(random, 2);
+		return cube;
+	}
+	static fromSquareOneState(state) {
+		const cube = new FullCube();
+		for (let index = 0; index < 24; index += 1) cube.setPiece(SQUARE_ONE_TO_FULL_CUBE_POSITION[index], SQUARE_ONE_TO_FULL_CUBE_PIECE[state.pieces[index]]);
+		cube.setPiece(24, state.sliceSolved ? 0 : 1);
+		return cube;
+	}
+	copy(cube) {
+		this.ul = cube.ul;
+		this.ur = cube.ur;
+		this.dl = cube.dl;
+		this.dr = cube.dr;
+		this.ml = cube.ml;
+	}
+	isSolved() {
+		return this.ul === SOLVED_UL && this.ur === SOLVED_UR && this.dl === SOLVED_DL && this.dr === SOLVED_DR && this.ml === 0;
+	}
+	doMove(move) {
+		let turn = move << 2;
+		if (turn > 24) {
+			turn = 48 - turn;
+			const oldUl = this.ul;
+			this.ul = (this.ul >> turn | this.ur << 24 - turn) & FACE_MASK;
+			this.ur = (this.ur >> turn | oldUl << 24 - turn) & FACE_MASK;
+		} else if (turn > 0) {
+			const oldUl = this.ul;
+			this.ul = (this.ul << turn | this.ur >> 24 - turn) & FACE_MASK;
+			this.ur = (this.ur << turn | oldUl >> 24 - turn) & FACE_MASK;
+		} else if (turn === 0) {
+			const oldUr = this.ur;
+			this.ur = this.dl;
+			this.dl = oldUr;
+			this.ml = 1 - this.ml;
+		} else if (turn >= -24) {
+			turn = -turn;
+			const oldDl = this.dl;
+			this.dl = (this.dl << turn | this.dr >> 24 - turn) & FACE_MASK;
+			this.dr = (this.dr << turn | oldDl >> 24 - turn) & FACE_MASK;
+		} else {
+			turn = 48 + turn;
+			const oldDl = this.dl;
+			this.dl = (this.dl >> turn | this.dr << 24 - turn) & FACE_MASK;
+			this.dr = (this.dr >> turn | oldDl << 24 - turn) & FACE_MASK;
+		}
+	}
+	setPiece(index, value) {
+		if (index < 6) {
+			const shift = 5 - index << 2;
+			this.ul &= ~(15 << shift);
+			this.ul |= value << shift;
+		} else if (index < 12) {
+			const shift = 11 - index << 2;
+			this.ur &= ~(15 << shift);
+			this.ur |= value << shift;
+		} else if (index < 18) {
+			const shift = 17 - index << 2;
+			this.dl &= ~(15 << shift);
+			this.dl |= value << shift;
+		} else if (index < 24) {
+			const shift = 23 - index << 2;
+			this.dr &= ~(15 << shift);
+			this.dr |= value << shift;
+		} else this.ml = value;
+	}
+	getShapeIdx() {
+		const urShape = extractShapeBits(this.ur);
+		const ulShape = extractShapeBits(this.ul);
+		const drShape = extractShapeBits(this.dr);
+		const dlShape = extractShapeBits(this.dl);
+		return getShape2Idx(this.getParity() << 24 | ulShape << 18 | urShape << 12 | dlShape << 6 | drShape);
+	}
+	getSquare(square = createSquareCoordinate()) {
+		const pieces = this.permutationScratch;
+		for (let index = 0; index < 8; index += 1) pieces[index] = this.pieceAt(index * 3 + 1) >> 1;
+		square.cornPerm = get8Perm(pieces);
+		square.topEdgeFirst = this.pieceAt(0) === this.pieceAt(1);
+		let position = square.topEdgeFirst ? 2 : 0;
+		let pieceIndex = 0;
+		for (; pieceIndex < 4; position += 3, pieceIndex += 1) pieces[pieceIndex] = this.pieceAt(position) >> 1;
+		square.botEdgeFirst = this.pieceAt(12) === this.pieceAt(13);
+		position = square.botEdgeFirst ? 14 : 12;
+		for (; pieceIndex < 8; position += 3, pieceIndex += 1) pieces[pieceIndex] = this.pieceAt(position) >> 1;
+		square.edgePerm = get8Perm(pieces);
+		square.ml = this.ml;
+		return square;
+	}
+	pieceAt(index) {
+		let piece;
+		if (index < 6) piece = this.ul >> (5 - index << 2);
+		else if (index < 12) piece = this.ur >> (11 - index << 2);
+		else if (index < 18) piece = this.dl >> (17 - index << 2);
+		else piece = this.dr >> (23 - index << 2);
+		return piece & 15;
+	}
+	getParity() {
+		const pieces = this.parityScratch;
+		let pieceCount = 0;
+		pieces[0] = this.pieceAt(0);
+		for (let index = 1; index < 24; index += 1) {
+			const piece = this.pieceAt(index);
+			if (piece !== pieces[pieceCount]) {
+				pieceCount += 1;
+				pieces[pieceCount] = piece;
+			}
+		}
+		let parity = 0;
+		for (let first = 0; first < 16; first += 1) for (let second = first + 1; second < 16; second += 1) if (pieces[first] > pieces[second]) parity ^= 1;
+		return parity;
+	}
+};
+const extractShapeBits = (face) => {
+	let shape = face & 1118481;
+	shape |= shape >> 3;
+	shape |= shape >> 6;
+	return shape & 15 | shape >> 12 & 48;
+};
+const removeNibble = (value, shift) => {
+	const mask = (1 << shift) - 1;
+	return (value & mask) + (value >> 4 & ~mask);
+};
+const drawRandomInt = (random, maxExclusive) => {
+	const value = random.nextInt(maxExclusive);
+	if (!Number.isSafeInteger(value) || value < 0 || value >= maxExclusive) throw new RangeError(`${ERROR_PREFIX}: Square-1 random source returned ${value} for max ${maxExclusive}`);
+	return value;
+};
+//#endregion
+export { FullCube };