cubegin 0.0.1

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

@@ -0,0 +1,554 @@
+import { move2str, parity, set8Perm, swap, toMove } from "./tables.mjs";
+import { Center1 } from "./center.mjs";
+import { EdgeCube } from "./edge.mjs";
+//#region .build/vendor/scramble-core/src/solvers/threephase/full-cube.ts
+const u0 = 0;
+const u1 = 1;
+const u2 = 2;
+const u3 = 3;
+const u4 = 4;
+const u5 = 5;
+const u6 = 6;
+const u7 = 7;
+const u8 = 8;
+const u9 = 9;
+const ua = 10;
+const ub = 11;
+const uc = 12;
+const ud = 13;
+const ue = 14;
+const uf = 15;
+const r0 = 16;
+const r1 = 17;
+const r2 = 18;
+const r3 = 19;
+const r4 = 20;
+const r5 = 21;
+const r6 = 22;
+const r7 = 23;
+const r8 = 24;
+const r9 = 25;
+const ra = 26;
+const rb = 27;
+const rc = 28;
+const rd = 29;
+const re = 30;
+const rf = 31;
+const f0 = 32;
+const f1 = 33;
+const f2 = 34;
+const f3 = 35;
+const f4 = 36;
+const f5 = 37;
+const f6 = 38;
+const f7 = 39;
+const f8 = 40;
+const f9 = 41;
+const fa = 42;
+const fb = 43;
+const fc = 44;
+const fd = 45;
+const fe = 46;
+const ff = 47;
+const d0 = 48;
+const d1 = 49;
+const d2 = 50;
+const d3 = 51;
+const d4 = 52;
+const d5 = 53;
+const d6 = 54;
+const d7 = 55;
+const d8 = 56;
+const d9 = 57;
+const da = 58;
+const db = 59;
+const dc = 60;
+const dd = 61;
+const de = 62;
+const df = 63;
+const l0 = 64;
+const l1 = 65;
+const l2 = 66;
+const l3 = 67;
+const l4 = 68;
+const l5 = 69;
+const l6 = 70;
+const l7 = 71;
+const l8 = 72;
+const l9 = 73;
+const la = 74;
+const lb = 75;
+const lc = 76;
+const ld = 77;
+const le = 78;
+const lf = 79;
+const b0 = 80;
+const b1 = 81;
+const b2 = 82;
+const b3 = 83;
+const b4 = 84;
+const b5 = 85;
+const b6 = 86;
+const b7 = 87;
+const b8 = 88;
+const b9 = 89;
+const ba = 90;
+const bb = 91;
+const bc = 92;
+const bd = 93;
+const be = 94;
+const bf = 95;
+var CenterCube = class CenterCube {
+	ct = Array.from({ length: 24 }, (_, index) => Math.floor(FullCube.centerFacelet[index] / 16));
+	static random(random) {
+		const cube = new CenterCube();
+		for (let i = 0; i < 23; i += 1) {
+			const t = i + random.nextInt(24 - i);
+			if (cube.ct[t] !== cube.ct[i]) {
+				const value = cube.ct[i];
+				cube.ct[i] = cube.ct[t];
+				cube.ct[t] = value;
+			}
+		}
+		return cube;
+	}
+	copy(center) {
+		for (let i = 0; i < 24; i += 1) this.ct[i] = center.ct[i];
+	}
+	fill333Facelet(facelet) {
+		const center333Map = [
+			0,
+			4,
+			2,
+			1,
+			5,
+			3
+		];
+		for (let i = 0; i < 6; i += 1) {
+			const idx = center333Map[i] << 2;
+			if (this.ct[idx] !== this.ct[idx + 1] || this.ct[idx + 1] !== this.ct[idx + 2] || this.ct[idx + 2] !== this.ct[idx + 3]) throw new Error("@cubegin/scramble-core: unsolved 4x4 centers after reduction");
+			facelet[4 + i * 9] = "URFDLB"[this.ct[idx]];
+		}
+	}
+	move(move) {
+		const key = move % 3;
+		switch (Math.floor(move / 3)) {
+			case 0:
+				swap(this.ct, 0, 1, 2, 3, key);
+				break;
+			case 1:
+				swap(this.ct, 16, 17, 18, 19, key);
+				break;
+			case 2:
+				swap(this.ct, 8, 9, 10, 11, key);
+				break;
+			case 3:
+				swap(this.ct, 4, 5, 6, 7, key);
+				break;
+			case 4:
+				swap(this.ct, 20, 21, 22, 23, key);
+				break;
+			case 5:
+				swap(this.ct, 12, 13, 14, 15, key);
+				break;
+			case 6:
+				swap(this.ct, 0, 1, 2, 3, key);
+				swap(this.ct, 8, 20, 12, 16, key);
+				swap(this.ct, 9, 21, 13, 17, key);
+				break;
+			case 7:
+				swap(this.ct, 16, 17, 18, 19, key);
+				swap(this.ct, 1, 15, 5, 9, key);
+				swap(this.ct, 2, 12, 6, 10, key);
+				break;
+			case 8:
+				swap(this.ct, 8, 9, 10, 11, key);
+				swap(this.ct, 2, 19, 4, 21, key);
+				swap(this.ct, 3, 16, 5, 22, key);
+				break;
+			case 9:
+				swap(this.ct, 4, 5, 6, 7, key);
+				swap(this.ct, 10, 18, 14, 22, key);
+				swap(this.ct, 11, 19, 15, 23, key);
+				break;
+			case 10:
+				swap(this.ct, 20, 21, 22, 23, key);
+				swap(this.ct, 0, 8, 4, 14, key);
+				swap(this.ct, 3, 11, 7, 13, key);
+				break;
+			case 11:
+				swap(this.ct, 12, 13, 14, 15, key);
+				swap(this.ct, 1, 20, 7, 18, key);
+				swap(this.ct, 0, 23, 6, 17, key);
+				break;
+		}
+	}
+};
+var CornerCube = class CornerCube {
+	static moveCube = Array.from({ length: 18 }, () => null);
+	static cornerFacelet = [
+		[
+			8,
+			9,
+			20
+		],
+		[
+			6,
+			18,
+			38
+		],
+		[
+			0,
+			36,
+			47
+		],
+		[
+			2,
+			45,
+			11
+		],
+		[
+			29,
+			26,
+			15
+		],
+		[
+			27,
+			44,
+			24
+		],
+		[
+			33,
+			53,
+			42
+		],
+		[
+			35,
+			17,
+			51
+		]
+	];
+	cp = [
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7
+	];
+	co = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	];
+	temp = null;
+	constructor(initMoves = true) {
+		if (initMoves) CornerCube.initMove();
+	}
+	static random(random) {
+		return new CornerCube().setFromCoords(random.nextInt(40320), random.nextInt(2187));
+	}
+	static initMove() {
+		if (CornerCube.moveCube[0] !== null) return;
+		CornerCube.moveCube[0] = new CornerCube(false).setFromCoords(15120, 0);
+		CornerCube.moveCube[3] = new CornerCube(false).setFromCoords(21021, 1494);
+		CornerCube.moveCube[6] = new CornerCube(false).setFromCoords(8064, 1236);
+		CornerCube.moveCube[9] = new CornerCube(false).setFromCoords(9, 0);
+		CornerCube.moveCube[12] = new CornerCube(false).setFromCoords(1230, 412);
+		CornerCube.moveCube[15] = new CornerCube(false).setFromCoords(224, 137);
+		for (let axis = 0; axis < 18; axis += 3) for (let power = 0; power < 2; power += 1) {
+			const cube = new CornerCube(false);
+			CornerCube.cornerMult(CornerCube.moveCube[axis + power], CornerCube.moveCube[axis], cube);
+			CornerCube.moveCube[axis + power + 1] = cube;
+		}
+	}
+	static cornerMult(first, second, product) {
+		for (let corner = 0; corner < 8; corner += 1) {
+			product.cp[corner] = first.cp[second.cp[corner]];
+			const oriA = first.co[second.cp[corner]];
+			const oriB = second.co[corner];
+			let ori = oriA;
+			ori += oriA < 3 ? oriB : 6 - oriB;
+			ori %= 3;
+			if (oriA >= 3 !== oriB >= 3) ori += 3;
+			product.co[corner] = ori;
+		}
+	}
+	copy(corner) {
+		for (let i = 0; i < 8; i += 1) {
+			this.cp[i] = corner.cp[i];
+			this.co[i] = corner.co[i];
+		}
+	}
+	getParity() {
+		return parity(this.cp);
+	}
+	fill333Facelet(facelet) {
+		for (let corner = 0; corner < 8; corner += 1) {
+			const cubie = this.cp[corner];
+			const orientation = this.co[corner];
+			for (let n = 0; n < 3; n += 1) facelet[CornerCube.cornerFacelet[corner][(n + orientation) % 3]] = "URFDLB"[Math.floor(CornerCube.cornerFacelet[cubie][n] / 9)];
+		}
+	}
+	move(move) {
+		this.temp ??= new CornerCube(false);
+		CornerCube.cornerMult(this, CornerCube.moveCube[move], this.temp);
+		this.copy(this.temp);
+	}
+	setFromCoords(cperm, twist) {
+		this.setCPerm(cperm);
+		this.setTwist(twist);
+		return this;
+	}
+	setTwist(index) {
+		let twist = 0;
+		for (let i = 6; i >= 0; i -= 1) {
+			this.co[i] = index % 3;
+			twist += this.co[i];
+			index = Math.floor(index / 3);
+		}
+		this.co[7] = (15 - twist) % 3;
+	}
+	setCPerm(index) {
+		set8Perm(this.cp, index);
+	}
+};
+var FullCube = class FullCube {
+	static centerFacelet = [
+		u5,
+		u6,
+		ua,
+		u9,
+		d5,
+		d6,
+		da,
+		d9,
+		f5,
+		f6,
+		fa,
+		f9,
+		b5,
+		b6,
+		ba,
+		b9,
+		r5,
+		r6,
+		ra,
+		r9,
+		l5,
+		l6,
+		la,
+		l9
+	];
+	static edgeFacelet = [
+		[ud, f1],
+		[u4, l1],
+		[u2, b1],
+		[ub, r1],
+		[dd, be],
+		[d4, le],
+		[d2, fe],
+		[db, re],
+		[lb, f8],
+		[l4, b7],
+		[rb, b8],
+		[r4, f7],
+		[f2, ue],
+		[l2, u8],
+		[b2, u1],
+		[r2, u7],
+		[bd, de],
+		[ld, d8],
+		[fd, d1],
+		[rd, d7],
+		[f4, l7],
+		[bb, l8],
+		[b4, r7],
+		[fb, r8]
+	];
+	static cornerFacelet = [
+		[
+			uf,
+			r0,
+			f3
+		],
+		[
+			uc,
+			f0,
+			l3
+		],
+		[
+			u0,
+			l0,
+			b3
+		],
+		[
+			u3,
+			b0,
+			r3
+		],
+		[
+			d3,
+			ff,
+			rc
+		],
+		[
+			d0,
+			lf,
+			fc
+		],
+		[
+			dc,
+			bf,
+			lc
+		],
+		[
+			df,
+			rf,
+			bc
+		]
+	];
+	value = 0;
+	add1 = false;
+	length1 = 0;
+	length2 = 0;
+	length3 = 0;
+	sym = 0;
+	edge;
+	center;
+	corner;
+	moveBuffer = Array.from({ length: 80 }, () => 0);
+	moveLength = 0;
+	edgeAvail = 0;
+	centerAvail = 0;
+	cornerAvail = 0;
+	constructor(source) {
+		this.edge = new EdgeCube();
+		this.center = new CenterCube();
+		this.corner = new CornerCube();
+		if (source !== void 0) this.copy(source);
+	}
+	static random(random) {
+		const cube = new FullCube();
+		cube.edge = EdgeCube.random(random);
+		cube.center = CenterCube.random(random);
+		cube.corner = CornerCube.random(random);
+		return cube;
+	}
+	static fromMoves(moves) {
+		const cube = new FullCube();
+		const sequence = typeof moves === "string" ? toMove(moves) : moves;
+		for (const move of sequence) cube.doMove(move);
+		return cube;
+	}
+	copy(cube) {
+		this.edge.copy(cube.edge);
+		this.center.copy(cube.center);
+		this.corner.copy(cube.corner);
+		this.value = cube.value;
+		this.add1 = cube.add1;
+		this.length1 = cube.length1;
+		this.length2 = cube.length2;
+		this.length3 = cube.length3;
+		this.sym = cube.sym;
+		for (let i = 0; i < this.moveBuffer.length; i += 1) this.moveBuffer[i] = cube.moveBuffer[i];
+		this.moveLength = cube.moveLength;
+		this.edgeAvail = cube.edgeAvail;
+		this.centerAvail = cube.centerAvail;
+		this.cornerAvail = cube.cornerAvail;
+	}
+	checkEdge() {
+		return this.getEdge().checkEdge();
+	}
+	getMoveString(inverse, rotation) {
+		const fixedMoves = Array.from({ length: this.moveLength - (this.add1 ? 2 : 0) }, () => 0);
+		let idx = 0;
+		for (let i = 0; i < this.length1; i += 1) fixedMoves[idx++] = this.moveBuffer[i];
+		let sym = this.sym;
+		for (let i = this.length1 + (this.add1 ? 2 : 0); i < this.moveLength; i += 1) {
+			const moved = Center1.symmove[sym][this.moveBuffer[i]];
+			if (moved >= 27) {
+				fixedMoves[idx++] = moved - 9;
+				const rot = MOVE_TO_ROT[moved - 27];
+				sym = Center1.symmult[sym][rot];
+			} else fixedMoves[idx++] = moved;
+		}
+		const finishSym = Center1.symmult[Center1.syminv[sym]][Center1.getSolvedSym(this.getCenter())];
+		const tokens = [];
+		sym = finishSym;
+		if (inverse) {
+			for (let i = idx - 1; i >= 0; i -= 1) {
+				let move = fixedMoves[i];
+				move = Math.floor(move / 3) * 3 + (2 - move % 3);
+				const moved = Center1.symmove[sym][move];
+				if (moved >= 27) {
+					tokens.push(move2str[moved - 9]);
+					const rot = MOVE_TO_ROT[moved - 27];
+					sym = Center1.symmult[sym][rot];
+				} else tokens.push(move2str[moved]);
+			}
+			if (rotation && Center1.rot2str[Center1.syminv[sym]] !== "") tokens.push(...Center1.rot2str[Center1.syminv[sym]].split(" "));
+		} else {
+			for (let i = 0; i < idx; i += 1) tokens.push(move2str[fixedMoves[i]]);
+			if (rotation && Center1.rot2str[finishSym] !== "") tokens.push(...Center1.rot2str[finishSym].split(" "));
+		}
+		return tokens.filter((token) => token.length > 0).join(" ");
+	}
+	to333Facelet() {
+		const facelet = Array.from({ length: 54 }, () => "");
+		this.getEdge().fill333Facelet(facelet);
+		this.getCenter().fill333Facelet(facelet);
+		this.getCorner().fill333Facelet(facelet);
+		return facelet.join("");
+	}
+	move(move) {
+		this.moveBuffer[this.moveLength] = move;
+		this.moveLength += 1;
+	}
+	doMove(move) {
+		this.getEdge().move(move);
+		this.getCenter().move(move);
+		this.getCorner().move(move % 18);
+	}
+	getEdge() {
+		while (this.edgeAvail < this.moveLength) {
+			this.edge.move(this.moveBuffer[this.edgeAvail]);
+			this.edgeAvail += 1;
+		}
+		return this.edge;
+	}
+	getCenter() {
+		while (this.centerAvail < this.moveLength) {
+			this.center.move(this.moveBuffer[this.centerAvail]);
+			this.centerAvail += 1;
+		}
+		return this.center;
+	}
+	getCorner() {
+		while (this.cornerAvail < this.moveLength) {
+			this.corner.move(this.moveBuffer[this.cornerAvail] % 18);
+			this.cornerAvail += 1;
+		}
+		return this.corner;
+	}
+};
+const MOVE_TO_ROT = [
+	35,
+	1,
+	34,
+	2,
+	4,
+	6,
+	22,
+	5,
+	19
+];
+//#endregion
+export { FullCube };