feat: reposition solver controls to a dropdown
Moved the Kociemba/Beginner solve options into a sleek dropdown menu positioned above the Scramble button on the left side of the screen. This ensures the solver controls no longer obstruct the programmatic move queue at the bottom.
This commit is contained in:
398
src/utils/DeepCube.js
Normal file
398
src/utils/DeepCube.js
Normal file
@@ -0,0 +1,398 @@
|
||||
// Corner indices
|
||||
export const CORNERS = {
|
||||
URF: 0,
|
||||
UFL: 1,
|
||||
ULB: 2,
|
||||
UBR: 3,
|
||||
DFR: 4,
|
||||
DLF: 5,
|
||||
DBL: 6,
|
||||
DRB: 7,
|
||||
};
|
||||
|
||||
// Edge indices
|
||||
export const EDGES = {
|
||||
UR: 0,
|
||||
UF: 1,
|
||||
UL: 2,
|
||||
UB: 3,
|
||||
DR: 4,
|
||||
DF: 5,
|
||||
DL: 6,
|
||||
DB: 7,
|
||||
FR: 8,
|
||||
FL: 9,
|
||||
BL: 10,
|
||||
BR: 11,
|
||||
};
|
||||
|
||||
export class DeepCube {
|
||||
constructor(cp, co, ep, eo) {
|
||||
if (cp && co && ep && eo) {
|
||||
this.cp = [...cp];
|
||||
this.co = [...co];
|
||||
this.ep = [...ep];
|
||||
this.eo = [...eo];
|
||||
} else {
|
||||
// Solved identity state
|
||||
this.cp = [0, 1, 2, 3, 4, 5, 6, 7];
|
||||
this.co = [0, 0, 0, 0, 0, 0, 0, 0];
|
||||
this.ep = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
|
||||
this.eo = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
||||
}
|
||||
}
|
||||
|
||||
// Multiply (apply) another cube state to this one.
|
||||
multiply(b) {
|
||||
const cp = new Array(8);
|
||||
const co = new Array(8);
|
||||
const ep = new Array(12);
|
||||
const eo = new Array(12);
|
||||
|
||||
// Corners
|
||||
for (let i = 0; i < 8; i++) {
|
||||
cp[i] = this.cp[b.cp[i]];
|
||||
co[i] = (this.co[b.cp[i]] + b.co[i]) % 3;
|
||||
}
|
||||
|
||||
// Edges
|
||||
for (let i = 0; i < 12; i++) {
|
||||
ep[i] = this.ep[b.ep[i]];
|
||||
eo[i] = (this.eo[b.ep[i]] + b.eo[i]) % 2;
|
||||
}
|
||||
|
||||
return new DeepCube(cp, co, ep, eo);
|
||||
}
|
||||
|
||||
clone() {
|
||||
return new DeepCube(this.cp, this.co, this.ep, this.eo);
|
||||
}
|
||||
|
||||
// Checks if the mathematical state is solvable/possible
|
||||
isValid() {
|
||||
// 1. Edge parity must equal corner parity
|
||||
let edgeParity = 0;
|
||||
for (let i = 11; i >= 0; i--) {
|
||||
for (let j = i - 1; j >= 0; j--) {
|
||||
if (this.ep[j] > this.ep[i]) edgeParity++;
|
||||
}
|
||||
}
|
||||
|
||||
let cornerParity = 0;
|
||||
for (let i = 7; i >= 0; i--) {
|
||||
for (let j = i - 1; j >= 0; j--) {
|
||||
if (this.cp[j] > this.cp[i]) cornerParity++;
|
||||
}
|
||||
}
|
||||
if (edgeParity % 2 !== cornerParity % 2) return false;
|
||||
|
||||
// 2. Edge orientations must sum to even
|
||||
let eoSum = this.eo.reduce((a, b) => a + b, 0);
|
||||
if (eoSum % 2 !== 0) return false;
|
||||
|
||||
// 3. Corner orientations must be divisible by 3
|
||||
let coSum = this.co.reduce((a, b) => a + b, 0);
|
||||
if (coSum % 3 !== 0) return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static fromCubies(cubies) {
|
||||
const c2f = {
|
||||
white: "U",
|
||||
yellow: "D",
|
||||
orange: "L",
|
||||
red: "R",
|
||||
green: "F",
|
||||
blue: "B",
|
||||
};
|
||||
|
||||
const getCubie = (x, y, z) =>
|
||||
cubies.find((c) => c.x === x && c.y === y && c.z === z);
|
||||
|
||||
const baseC = [
|
||||
["U", "R", "F"],
|
||||
["U", "F", "L"],
|
||||
["U", "L", "B"],
|
||||
["U", "B", "R"],
|
||||
["D", "F", "R"],
|
||||
["D", "L", "F"],
|
||||
["D", "B", "L"],
|
||||
["D", "R", "B"],
|
||||
];
|
||||
|
||||
const slotC = [
|
||||
{ x: 1, y: 1, z: 1, faces: ["up", "right", "front"] }, // 0: URF
|
||||
{ x: -1, y: 1, z: 1, faces: ["up", "front", "left"] }, // 1: UFL
|
||||
{ x: -1, y: 1, z: -1, faces: ["up", "left", "back"] }, // 2: ULB
|
||||
{ x: 1, y: 1, z: -1, faces: ["up", "back", "right"] }, // 3: UBR
|
||||
{ x: 1, y: -1, z: 1, faces: ["down", "front", "right"] }, // 4: DFR
|
||||
{ x: -1, y: -1, z: 1, faces: ["down", "left", "front"] }, // 5: DLF
|
||||
{ x: -1, y: -1, z: -1, faces: ["down", "back", "left"] }, // 6: DBL
|
||||
{ x: 1, y: -1, z: -1, faces: ["down", "right", "back"] }, // 7: DRB
|
||||
];
|
||||
|
||||
let cp = [],
|
||||
co = [];
|
||||
for (let i = 0; i < 8; i++) {
|
||||
let slot = slotC[i];
|
||||
let c = getCubie(slot.x, slot.y, slot.z);
|
||||
let colors = [
|
||||
c2f[c.faces[slot.faces[0]]],
|
||||
c2f[c.faces[slot.faces[1]]],
|
||||
c2f[c.faces[slot.faces[2]]],
|
||||
];
|
||||
let perm = baseC.findIndex(
|
||||
(bc) =>
|
||||
colors.includes(bc[0]) &&
|
||||
colors.includes(bc[1]) &&
|
||||
colors.includes(bc[2]),
|
||||
);
|
||||
cp[i] = perm;
|
||||
co[i] = colors.indexOf(baseC[perm][0]);
|
||||
}
|
||||
|
||||
const baseE = [
|
||||
["U", "R"],
|
||||
["U", "F"],
|
||||
["U", "L"],
|
||||
["U", "B"],
|
||||
["D", "R"],
|
||||
["D", "F"],
|
||||
["D", "L"],
|
||||
["D", "B"],
|
||||
["F", "R"],
|
||||
["F", "L"],
|
||||
["B", "L"],
|
||||
["B", "R"],
|
||||
];
|
||||
|
||||
const slotE = [
|
||||
{ x: 1, y: 1, z: 0, faces: ["up", "right"] },
|
||||
{ x: 0, y: 1, z: 1, faces: ["up", "front"] },
|
||||
{ x: -1, y: 1, z: 0, faces: ["up", "left"] },
|
||||
{ x: 0, y: 1, z: -1, faces: ["up", "back"] },
|
||||
{ x: 1, y: -1, z: 0, faces: ["down", "right"] },
|
||||
{ x: 0, y: -1, z: 1, faces: ["down", "front"] },
|
||||
{ x: -1, y: -1, z: 0, faces: ["down", "left"] },
|
||||
{ x: 0, y: -1, z: -1, faces: ["down", "back"] },
|
||||
{ x: 1, y: 0, z: 1, faces: ["front", "right"] },
|
||||
{ x: -1, y: 0, z: 1, faces: ["front", "left"] },
|
||||
{ x: -1, y: 0, z: -1, faces: ["back", "left"] },
|
||||
{ x: 1, y: 0, z: -1, faces: ["back", "right"] },
|
||||
];
|
||||
|
||||
let ep = [],
|
||||
eo = [];
|
||||
for (let i = 0; i < 12; i++) {
|
||||
let slot = slotE[i];
|
||||
let c = getCubie(slot.x, slot.y, slot.z);
|
||||
let colors = [c2f[c.faces[slot.faces[0]]], c2f[c.faces[slot.faces[1]]]];
|
||||
let perm = baseE.findIndex(
|
||||
(be) => colors.includes(be[0]) && colors.includes(be[1]),
|
||||
);
|
||||
ep[i] = perm;
|
||||
eo[i] = colors.indexOf(baseE[perm][0]);
|
||||
}
|
||||
|
||||
return new DeepCube(cp, co, ep, eo);
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// BASE MOVES DEFINITIONS
|
||||
// Represents the effect of 90-degree clockwise faces on the solved state.
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
export const MOVES = {};
|
||||
|
||||
// U (Up Face Clockwise)
|
||||
MOVES["U"] = new DeepCube(
|
||||
[
|
||||
CORNERS.UBR,
|
||||
CORNERS.URF,
|
||||
CORNERS.UFL,
|
||||
CORNERS.ULB,
|
||||
CORNERS.DFR,
|
||||
CORNERS.DLF,
|
||||
CORNERS.DBL,
|
||||
CORNERS.DRB,
|
||||
],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0],
|
||||
[
|
||||
EDGES.UB,
|
||||
EDGES.UR,
|
||||
EDGES.UF,
|
||||
EDGES.UL,
|
||||
EDGES.DR,
|
||||
EDGES.DF,
|
||||
EDGES.DL,
|
||||
EDGES.DB,
|
||||
EDGES.FR,
|
||||
EDGES.FL,
|
||||
EDGES.BL,
|
||||
EDGES.BR,
|
||||
],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
);
|
||||
|
||||
// R (Right Face Clockwise)
|
||||
MOVES["R"] = new DeepCube(
|
||||
[
|
||||
CORNERS.DFR,
|
||||
CORNERS.UFL,
|
||||
CORNERS.ULB,
|
||||
CORNERS.URF,
|
||||
CORNERS.DRB,
|
||||
CORNERS.DLF,
|
||||
CORNERS.DBL,
|
||||
CORNERS.UBR,
|
||||
],
|
||||
[2, 0, 0, 1, 1, 0, 0, 2],
|
||||
[
|
||||
EDGES.FR,
|
||||
EDGES.UF,
|
||||
EDGES.UL,
|
||||
EDGES.UB,
|
||||
EDGES.BR,
|
||||
EDGES.DF,
|
||||
EDGES.DL,
|
||||
EDGES.DB,
|
||||
EDGES.DR,
|
||||
EDGES.FL,
|
||||
EDGES.BL,
|
||||
EDGES.UR,
|
||||
],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
);
|
||||
|
||||
// F (Front Face Clockwise)
|
||||
MOVES["F"] = new DeepCube(
|
||||
[
|
||||
CORNERS.UFL,
|
||||
CORNERS.DLF,
|
||||
CORNERS.ULB,
|
||||
CORNERS.UBR,
|
||||
CORNERS.URF,
|
||||
CORNERS.DFR,
|
||||
CORNERS.DBL,
|
||||
CORNERS.DRB,
|
||||
],
|
||||
[1, 2, 0, 0, 2, 1, 0, 0],
|
||||
[
|
||||
EDGES.UR,
|
||||
EDGES.FL,
|
||||
EDGES.UL,
|
||||
EDGES.UB,
|
||||
EDGES.DR,
|
||||
EDGES.FR,
|
||||
EDGES.DL,
|
||||
EDGES.DB,
|
||||
EDGES.UF,
|
||||
EDGES.DF,
|
||||
EDGES.BL,
|
||||
EDGES.BR,
|
||||
],
|
||||
[0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0],
|
||||
);
|
||||
|
||||
// D (Down Face Clockwise)
|
||||
MOVES["D"] = new DeepCube(
|
||||
[
|
||||
CORNERS.URF,
|
||||
CORNERS.UFL,
|
||||
CORNERS.ULB,
|
||||
CORNERS.UBR,
|
||||
CORNERS.DLF,
|
||||
CORNERS.DBL,
|
||||
CORNERS.DRB,
|
||||
CORNERS.DFR,
|
||||
],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0],
|
||||
[
|
||||
EDGES.UR,
|
||||
EDGES.UF,
|
||||
EDGES.UL,
|
||||
EDGES.UB,
|
||||
EDGES.DF,
|
||||
EDGES.DL,
|
||||
EDGES.DB,
|
||||
EDGES.DR,
|
||||
EDGES.FR,
|
||||
EDGES.FL,
|
||||
EDGES.BL,
|
||||
EDGES.BR,
|
||||
],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
);
|
||||
|
||||
// L (Left Face Clockwise)
|
||||
MOVES["L"] = new DeepCube(
|
||||
[
|
||||
CORNERS.URF,
|
||||
CORNERS.ULB,
|
||||
CORNERS.DBL,
|
||||
CORNERS.UBR,
|
||||
CORNERS.DFR,
|
||||
CORNERS.UFL,
|
||||
CORNERS.DLF,
|
||||
CORNERS.DRB,
|
||||
],
|
||||
[0, 1, 2, 0, 0, 2, 1, 0],
|
||||
[
|
||||
EDGES.UR,
|
||||
EDGES.UF,
|
||||
EDGES.BL,
|
||||
EDGES.UB,
|
||||
EDGES.DR,
|
||||
EDGES.DF,
|
||||
EDGES.FL,
|
||||
EDGES.DB,
|
||||
EDGES.FR,
|
||||
EDGES.UL,
|
||||
EDGES.DL,
|
||||
EDGES.BR,
|
||||
],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
);
|
||||
|
||||
// B (Back Face Clockwise)
|
||||
MOVES["B"] = new DeepCube(
|
||||
[
|
||||
CORNERS.URF,
|
||||
CORNERS.UFL,
|
||||
CORNERS.UBR,
|
||||
CORNERS.DRB,
|
||||
CORNERS.DFR,
|
||||
CORNERS.DLF,
|
||||
CORNERS.ULB,
|
||||
CORNERS.DBL,
|
||||
],
|
||||
[0, 0, 1, 2, 0, 0, 2, 1],
|
||||
[
|
||||
EDGES.UR,
|
||||
EDGES.UF,
|
||||
EDGES.UL,
|
||||
EDGES.BR,
|
||||
EDGES.DR,
|
||||
EDGES.DF,
|
||||
EDGES.DL,
|
||||
EDGES.BL,
|
||||
EDGES.FR,
|
||||
EDGES.FL,
|
||||
EDGES.UB,
|
||||
EDGES.DB,
|
||||
],
|
||||
[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1],
|
||||
);
|
||||
|
||||
// Generate inverses and 180s
|
||||
const faces = ["U", "R", "F", "D", "L", "B"];
|
||||
faces.forEach((f) => {
|
||||
const m1 = MOVES[f];
|
||||
const m2 = m1.multiply(m1);
|
||||
const m3 = m2.multiply(m1);
|
||||
|
||||
MOVES[f + "2"] = m2;
|
||||
MOVES[f + "'"] = m3;
|
||||
});
|
||||
Reference in New Issue
Block a user