1626 lines
32 KiB
JavaScript
1626 lines
32 KiB
JavaScript
import {
|
|
indexToPosition,
|
|
isInside,
|
|
positionToUvs
|
|
} from "./chunk-ROHLD3FA.js";
|
|
import {
|
|
__privateAdd,
|
|
__privateGet,
|
|
__privateMethod,
|
|
__privateSet,
|
|
__publicField
|
|
} from "./chunk-HPRLEMBT.js";
|
|
|
|
// node_modules/rubiks-js/src/state/corners.js
|
|
var permutations = {
|
|
R: ["DRF", "ULF", "ULB", "URF", "DRB", "DLF", "DLB", "URB"],
|
|
L: ["URF", "ULB", "DLB", "URB", "DRF", "ULF", "DLF", "DRB"],
|
|
U: ["URB", "URF", "ULF", "ULB", "DRF", "DLF", "DLB", "DRB"],
|
|
D: ["URF", "ULF", "ULB", "URB", "DLF", "DLB", "DRB", "DRF"],
|
|
F: ["ULF", "DLF", "ULB", "URB", "URF", "DRF", "DLB", "DRB"],
|
|
B: ["URF", "ULF", "URB", "DRB", "DRF", "DLF", "ULB", "DLB"]
|
|
};
|
|
var orientations = {
|
|
R: [2, 0, 0, 1, 1, 0, 0, 2],
|
|
L: [0, 1, 2, 0, 0, 2, 1, 0],
|
|
U: [0, 0, 0, 0, 0, 0, 0, 0],
|
|
D: [0, 0, 0, 0, 0, 0, 0, 0],
|
|
F: [1, 2, 0, 0, 2, 1, 0, 0],
|
|
B: [0, 0, 1, 2, 0, 0, 2, 1]
|
|
};
|
|
var map = {
|
|
URF: {
|
|
URF: {
|
|
0: [],
|
|
1: ["R", "U"],
|
|
2: ["F'", "U'"]
|
|
},
|
|
ULF: {
|
|
0: ["U"],
|
|
1: ["R", "U2"],
|
|
2: ["F'"]
|
|
},
|
|
ULB: {
|
|
0: ["U2"],
|
|
1: ["R", "U'"],
|
|
2: ["F'", "U"]
|
|
},
|
|
URB: {
|
|
0: ["U'"],
|
|
1: ["R"],
|
|
2: ["F'", "U2"]
|
|
},
|
|
DRF: {
|
|
0: ["R2", "D'"],
|
|
1: ["R'"],
|
|
2: ["F"]
|
|
},
|
|
DLF: {
|
|
0: ["F2"],
|
|
1: ["R'", "D'"],
|
|
2: ["F", "D'"]
|
|
},
|
|
DLB: {
|
|
0: ["R2", "D"],
|
|
1: ["R'", "D2"],
|
|
2: ["F", "D2"]
|
|
},
|
|
DRB: {
|
|
0: ["R2"],
|
|
1: ["R'", "D"],
|
|
2: ["F", "D"]
|
|
}
|
|
},
|
|
ULF: {
|
|
URF: {
|
|
0: ["U'"],
|
|
1: ["F"],
|
|
2: ["L'", "U2"]
|
|
},
|
|
ULF: {
|
|
0: [],
|
|
1: ["F", "U"],
|
|
2: ["L'", "U'"]
|
|
},
|
|
ULB: {
|
|
0: ["U"],
|
|
1: ["F", "U2"],
|
|
2: ["L'"]
|
|
},
|
|
URB: {
|
|
0: ["U2"],
|
|
1: ["F", "U'"],
|
|
2: ["L'", "U"]
|
|
},
|
|
DRF: {
|
|
0: ["F2"],
|
|
1: ["F'", "D"],
|
|
2: ["L", "D"]
|
|
},
|
|
DLF: {
|
|
0: ["L2", "D"],
|
|
1: ["F'"],
|
|
2: ["L"]
|
|
},
|
|
DLB: {
|
|
0: ["L2"],
|
|
1: ["F'", "D'"],
|
|
2: ["L", "D'"]
|
|
},
|
|
DRB: {
|
|
0: ["L2", "D'"],
|
|
1: ["F'", "D2"],
|
|
2: ["L", "D2"]
|
|
}
|
|
},
|
|
ULB: {
|
|
URF: {
|
|
0: ["U2"],
|
|
1: ["L", "U'"],
|
|
2: ["B'", "U"]
|
|
},
|
|
ULF: {
|
|
0: ["U'"],
|
|
1: ["L"],
|
|
2: ["B'", "U2"]
|
|
},
|
|
ULB: {
|
|
0: [],
|
|
1: ["L", "U"],
|
|
2: ["B'", "U'"]
|
|
},
|
|
URB: {
|
|
0: ["U"],
|
|
1: ["L", "U2"],
|
|
2: ["B'"]
|
|
},
|
|
DRF: {
|
|
0: ["L2", "D"],
|
|
1: ["L'", "D2"],
|
|
2: ["B", "D2"]
|
|
},
|
|
DLF: {
|
|
0: ["L2"],
|
|
1: ["L'", "D"],
|
|
2: ["B", "D"]
|
|
},
|
|
DLB: {
|
|
0: ["L2", "D"],
|
|
1: ["L'"],
|
|
2: ["B"]
|
|
},
|
|
DRB: {
|
|
0: ["B2"],
|
|
1: ["L'", "D'"],
|
|
2: ["B", "D'"]
|
|
}
|
|
},
|
|
URB: {
|
|
URF: {
|
|
0: ["U"],
|
|
1: ["B", "U2"],
|
|
2: ["R'"]
|
|
},
|
|
ULF: {
|
|
0: ["U2"],
|
|
1: ["B", "U'"],
|
|
2: ["R'", "U"]
|
|
},
|
|
ULB: {
|
|
0: ["U'"],
|
|
1: ["B"],
|
|
2: ["R'", "U2"]
|
|
},
|
|
URB: {
|
|
0: [],
|
|
1: ["B", "U"],
|
|
2: ["R'", "U'"]
|
|
},
|
|
DRF: {
|
|
0: ["R2"],
|
|
1: ["B'", "D'"],
|
|
2: ["R", "D'"]
|
|
},
|
|
DLF: {
|
|
0: ["R2", "D'"],
|
|
1: ["B'", "D2"],
|
|
2: ["R", "D2"]
|
|
},
|
|
DLB: {
|
|
0: ["B2"],
|
|
1: ["B'", "D"],
|
|
2: ["R", "D"]
|
|
},
|
|
DRB: {
|
|
0: ["R2", "D"],
|
|
1: ["B'"],
|
|
2: ["R"]
|
|
}
|
|
},
|
|
DRF: {
|
|
URF: {
|
|
0: ["R2", "U"],
|
|
1: ["F'"],
|
|
2: ["R"]
|
|
},
|
|
ULF: {
|
|
0: ["F2"],
|
|
1: ["F'", "U"],
|
|
2: ["R", "U"]
|
|
},
|
|
ULB: {
|
|
0: ["R2", "U'"],
|
|
1: ["F'", "U2"],
|
|
2: ["R", "U2"]
|
|
},
|
|
URB: {
|
|
0: ["R2"],
|
|
1: ["F'", "U'"],
|
|
2: ["R", "U'"]
|
|
},
|
|
DRF: {
|
|
0: [],
|
|
1: ["F", "D"],
|
|
2: ["R'", "D'"]
|
|
},
|
|
DLF: {
|
|
0: ["D'"],
|
|
1: ["F"],
|
|
2: ["R'", "D2"]
|
|
},
|
|
DLB: {
|
|
0: ["D2"],
|
|
1: ["F", "D'"],
|
|
2: ["R'", "D"]
|
|
},
|
|
DRB: {
|
|
0: ["D"],
|
|
1: ["F", "D2"],
|
|
2: ["R'"]
|
|
}
|
|
},
|
|
DLF: {
|
|
URF: {
|
|
0: ["F2"],
|
|
1: ["L'", "U'"],
|
|
2: ["F", "U'"]
|
|
},
|
|
ULF: {
|
|
0: ["L2", "U'"],
|
|
1: ["L'"],
|
|
2: ["F"]
|
|
},
|
|
ULB: {
|
|
0: ["L2"],
|
|
1: ["L'", "U"],
|
|
2: ["F", "U"]
|
|
},
|
|
URB: {
|
|
0: ["L2", "U"],
|
|
1: ["L'", "U2"],
|
|
2: ["F", "U2"]
|
|
},
|
|
DRF: {
|
|
0: ["D"],
|
|
1: ["L", "D2"],
|
|
2: ["F'"]
|
|
},
|
|
DLF: {
|
|
0: [],
|
|
1: ["L", "D"],
|
|
2: ["F'", "D'"]
|
|
},
|
|
DLB: {
|
|
0: ["D'"],
|
|
1: ["L"],
|
|
2: ["F'", "D2"]
|
|
},
|
|
DRB: {
|
|
0: ["D2"],
|
|
1: ["L", "D'"],
|
|
2: ["F'", "D"]
|
|
}
|
|
},
|
|
DLB: {
|
|
URF: {
|
|
0: ["L2", "U'"],
|
|
1: ["B'", "U2"],
|
|
2: ["L", "U2"]
|
|
},
|
|
ULF: {
|
|
0: ["L2"],
|
|
1: ["B'", "U'"],
|
|
2: ["L", "U'"]
|
|
},
|
|
ULB: {
|
|
0: ["L2", "U"],
|
|
1: ["B'"],
|
|
2: ["L"]
|
|
},
|
|
URB: {
|
|
0: ["B2"],
|
|
1: ["B'", "U"],
|
|
2: ["L", "U"]
|
|
},
|
|
DRF: {
|
|
0: ["D2"],
|
|
1: ["B", "D'"],
|
|
2: ["L'", "D"]
|
|
},
|
|
DLF: {
|
|
0: ["D"],
|
|
1: ["B", "D2"],
|
|
2: ["L'"]
|
|
},
|
|
DLB: {
|
|
0: [],
|
|
1: ["B", "D"],
|
|
2: ["L'", "D'"]
|
|
},
|
|
DRB: {
|
|
0: ["D'"],
|
|
1: ["B"],
|
|
2: ["L'", "D2"]
|
|
}
|
|
},
|
|
DRB: {
|
|
URF: {
|
|
0: ["R2"],
|
|
1: ["R'", "U"],
|
|
2: ["B", "U"]
|
|
},
|
|
ULF: {
|
|
0: ["R2", "U"],
|
|
1: ["R'", "U2"],
|
|
2: ["B", "U2"]
|
|
},
|
|
ULB: {
|
|
0: ["B2"],
|
|
1: ["R'", "U'"],
|
|
2: ["B", "U'"]
|
|
},
|
|
URB: {
|
|
0: ["R2", "U'"],
|
|
1: ["R'"],
|
|
2: ["B"]
|
|
},
|
|
DRF: {
|
|
0: ["D'"],
|
|
1: ["R"],
|
|
2: ["B'", "D2"]
|
|
},
|
|
DLF: {
|
|
0: ["D2"],
|
|
1: ["R", "D'"],
|
|
2: ["B'", "D"]
|
|
},
|
|
DLB: {
|
|
0: ["D"],
|
|
1: ["R", "D2"],
|
|
2: ["B'"]
|
|
},
|
|
DRB: {
|
|
0: [],
|
|
1: ["R", "D"],
|
|
2: ["B'", "D'"]
|
|
}
|
|
}
|
|
};
|
|
var orderIndexToCubieIndex = [
|
|
6,
|
|
8,
|
|
26,
|
|
24,
|
|
0,
|
|
2,
|
|
20,
|
|
18
|
|
];
|
|
var _Corners_instances, getTurns_fn;
|
|
var _Corners = class _Corners {
|
|
constructor() {
|
|
__privateAdd(this, _Corners_instances);
|
|
/** @type {Permutation} */
|
|
__publicField(this, "permutation", [..._Corners.order]);
|
|
/** @type {Orientation} */
|
|
__publicField(this, "orientation", [0, 0, 0, 0, 0, 0, 0, 0]);
|
|
}
|
|
/** @param {TurnBase} turn */
|
|
applyTurn(turn) {
|
|
const appliedPermutation = permutations[turn];
|
|
const appliedOrientation = orientations[turn];
|
|
const permutation = [...this.permutation];
|
|
const orientation = [...this.orientation];
|
|
for (let i = 0; i < 8; i++) {
|
|
const newPermutation = appliedPermutation[i];
|
|
const orderIndex = _Corners.order.indexOf(newPermutation);
|
|
this.permutation[i] = permutation[orderIndex];
|
|
const newOrientation = (appliedOrientation[i] + orientation[orderIndex]) % 3;
|
|
this.orientation[i] = /** @type {CO} */
|
|
newOrientation;
|
|
}
|
|
}
|
|
/**
|
|
* @param {number[][][]} uvs
|
|
* @param {import('../ui/rubiks').Rubiks} rubiks
|
|
*/
|
|
applyState(uvs, rubiks) {
|
|
for (let i = 0; i < 8; i++) {
|
|
const turns = __privateMethod(this, _Corners_instances, getTurns_fn).call(this, i);
|
|
const originIndex = orderIndexToCubieIndex[_Corners.order.indexOf(this.permutation[i])];
|
|
let sideToUvs = createSideToUvs(originIndex, uvs);
|
|
sideToUvs = transformSidetoUvs(originIndex, sideToUvs, turns);
|
|
const targetIndex = orderIndexToCubieIndex[i];
|
|
setUvs(targetIndex, rubiks, sideToUvs);
|
|
}
|
|
}
|
|
reset() {
|
|
this.permutation = [..._Corners.order];
|
|
this.orientation = [0, 0, 0, 0, 0, 0, 0, 0];
|
|
}
|
|
/** @returns {number[]} */
|
|
encode() {
|
|
let p = 0;
|
|
for (const permutation of this.permutation) {
|
|
p = p << 3;
|
|
p += _Corners.order.indexOf(permutation);
|
|
}
|
|
let o = 0;
|
|
for (const orientation of this.orientation) {
|
|
o = o << 2;
|
|
o += orientation;
|
|
}
|
|
return [
|
|
p >> 0 & 255,
|
|
p >> 8 & 255,
|
|
p >> 16 & 255,
|
|
o >> 0 & 255,
|
|
o >> 8 & 255
|
|
];
|
|
}
|
|
/**
|
|
* @param {number[]} code
|
|
* @returns {boolean}
|
|
*/
|
|
decode(code) {
|
|
let p = code[0] + (code[1] << 8) + (code[2] << 16);
|
|
let o = code[3] + (code[4] << 8);
|
|
for (let i = 7; i >= 0; i--) {
|
|
const p1 = p & 7;
|
|
if (p1 >= 8) {
|
|
return false;
|
|
}
|
|
this.permutation[i] = _Corners.order[p1];
|
|
p = p >> 3;
|
|
const o1 = o & 3;
|
|
if (o1 > 2) {
|
|
return false;
|
|
}
|
|
this.orientation[i] = /** @type {CO} */
|
|
o1;
|
|
o = o >> 2;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
_Corners_instances = new WeakSet();
|
|
/**
|
|
* @param {number} index
|
|
* @returns {Turn[]}
|
|
*/
|
|
getTurns_fn = function(index) {
|
|
const start = _Corners.order[index];
|
|
const permutation = this.permutation[index];
|
|
const orientation = this.orientation[index];
|
|
return map[permutation][start][orientation];
|
|
};
|
|
/** @type {Permutation} */
|
|
__publicField(_Corners, "order", ["URF", "ULF", "ULB", "URB", "DRF", "DLF", "DLB", "DRB"]);
|
|
var Corners = _Corners;
|
|
|
|
// node_modules/rubiks-js/src/state/edges.js
|
|
var permutations2 = {
|
|
R: ["UF", "UL", "UB", "FR", "DR", "FL", "BL", "UR", "DF", "DL", "DB", "BR"],
|
|
L: ["UF", "BL", "UB", "UR", "FR", "UL", "DL", "BR", "DF", "FL", "DB", "DR"],
|
|
U: ["UR", "UF", "UL", "UB", "FR", "FL", "BL", "BR", "DF", "DL", "DB", "DR"],
|
|
D: ["UF", "UL", "UB", "UR", "FR", "FL", "BL", "BR", "DL", "DB", "DR", "DF"],
|
|
F: ["FL", "UL", "UB", "UR", "UF", "DF", "BL", "BR", "FR", "DL", "DB", "DR"],
|
|
B: ["UF", "UL", "BR", "UR", "FR", "FL", "UB", "DB", "DF", "DL", "BL", "DR"]
|
|
};
|
|
var orientations2 = {
|
|
R: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
L: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
U: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
D: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
F: [1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0],
|
|
B: [0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0]
|
|
};
|
|
var map2 = {
|
|
UF: {
|
|
UF: {
|
|
0: [],
|
|
1: ["F", "R", "U"]
|
|
},
|
|
UL: {
|
|
0: ["U"],
|
|
1: ["F'", "L'"]
|
|
},
|
|
UB: {
|
|
0: ["U2"],
|
|
1: ["F", "R", "U'"]
|
|
},
|
|
UR: {
|
|
0: ["U'"],
|
|
1: ["F", "R"]
|
|
},
|
|
FR: {
|
|
0: ["U'", "R'"],
|
|
1: ["F"]
|
|
},
|
|
FL: {
|
|
0: ["U", "L"],
|
|
1: ["F'"]
|
|
},
|
|
BL: {
|
|
0: ["U", "L'"],
|
|
1: ["U2", "B"]
|
|
},
|
|
BR: {
|
|
0: ["U'", "R"],
|
|
1: ["U2", "B'"]
|
|
},
|
|
DF: {
|
|
0: ["F2"],
|
|
1: ["F", "R'", "D'"]
|
|
},
|
|
DL: {
|
|
0: ["F2", "D'"],
|
|
1: ["F'", "L"]
|
|
},
|
|
DB: {
|
|
0: ["F2", "D2"],
|
|
1: ["F", "R'", "D"]
|
|
},
|
|
DR: {
|
|
0: ["F2", "D"],
|
|
1: ["F", "R'"]
|
|
}
|
|
},
|
|
UL: {
|
|
UF: {
|
|
0: ["U'"],
|
|
1: ["L", "F"]
|
|
},
|
|
UL: {
|
|
0: [],
|
|
1: ["L", "F", "U"]
|
|
},
|
|
UB: {
|
|
0: ["U"],
|
|
1: ["L'", "B'"]
|
|
},
|
|
UR: {
|
|
0: ["U2"],
|
|
1: ["L", "F", "U'"]
|
|
},
|
|
FR: {
|
|
0: ["U2", "R'"],
|
|
1: ["U'", "F"]
|
|
},
|
|
FL: {
|
|
0: ["L"],
|
|
1: ["U'", "F'"]
|
|
},
|
|
BL: {
|
|
0: ["L'"],
|
|
1: ["U", "B"]
|
|
},
|
|
BR: {
|
|
0: ["U2", "R"],
|
|
1: ["U", "B'"]
|
|
},
|
|
DF: {
|
|
0: ["L2", "D"],
|
|
1: ["L", "F'"]
|
|
},
|
|
DL: {
|
|
0: ["L2"],
|
|
1: ["L", "F'", "D'"]
|
|
},
|
|
DB: {
|
|
0: ["L2", "D'"],
|
|
1: ["L'", "B"]
|
|
},
|
|
DR: {
|
|
0: ["L2", "D2"],
|
|
1: ["L", "F'", "D"]
|
|
}
|
|
},
|
|
UB: {
|
|
UF: {
|
|
0: ["U2"],
|
|
1: ["B'", "R'", "U"]
|
|
},
|
|
UL: {
|
|
0: ["U'"],
|
|
1: ["B", "L"]
|
|
},
|
|
UB: {
|
|
0: [],
|
|
1: ["B'", "R'", "U'"]
|
|
},
|
|
UR: {
|
|
0: ["U"],
|
|
1: ["B'", "R'"]
|
|
},
|
|
FR: {
|
|
0: ["U", "R'"],
|
|
1: ["B'", "R2"]
|
|
},
|
|
FL: {
|
|
0: ["U'", "L"],
|
|
1: ["B", "L2"]
|
|
},
|
|
BL: {
|
|
0: ["U'", "L'"],
|
|
1: ["B"]
|
|
},
|
|
BR: {
|
|
0: ["U", "R"],
|
|
1: ["B'"]
|
|
},
|
|
DF: {
|
|
0: ["B2", "D2"],
|
|
1: ["B'", "R", "D'"]
|
|
},
|
|
DL: {
|
|
0: ["B2", "D"],
|
|
1: ["B", "L'"]
|
|
},
|
|
DB: {
|
|
0: ["B2"],
|
|
1: ["B'", "R", "D"]
|
|
},
|
|
DR: {
|
|
0: ["B2", "D'"],
|
|
1: ["B'", "R"]
|
|
}
|
|
},
|
|
UR: {
|
|
UF: {
|
|
0: ["U"],
|
|
1: ["R'", "F'"]
|
|
},
|
|
UL: {
|
|
0: ["U2"],
|
|
1: ["R'", "F'", "U"]
|
|
},
|
|
UB: {
|
|
0: ["U'"],
|
|
1: ["R", "B"]
|
|
},
|
|
UR: {
|
|
0: [],
|
|
1: ["R'", "F'", "U'"]
|
|
},
|
|
FR: {
|
|
0: ["R'"],
|
|
1: ["U", "F"]
|
|
},
|
|
FL: {
|
|
0: ["U2", "L"],
|
|
1: ["U", "F'"]
|
|
},
|
|
BL: {
|
|
0: ["U2", "L'"],
|
|
1: ["U'", "B"]
|
|
},
|
|
BR: {
|
|
0: ["R"],
|
|
1: ["U'", "B'"]
|
|
},
|
|
DF: {
|
|
0: ["R2", "D'"],
|
|
1: ["R'", "F"]
|
|
},
|
|
DL: {
|
|
0: ["R2", "D2"],
|
|
1: ["R'", "F", "D'"]
|
|
},
|
|
DB: {
|
|
0: ["R2", "D"],
|
|
1: ["R", "B'"]
|
|
},
|
|
DR: {
|
|
0: ["R2"],
|
|
1: ["R'", "F", "D"]
|
|
}
|
|
},
|
|
FR: {
|
|
UF: {
|
|
0: ["R", "U"],
|
|
1: ["F'"]
|
|
},
|
|
UL: {
|
|
0: ["R", "U2"],
|
|
1: ["F'", "U"]
|
|
},
|
|
UB: {
|
|
0: ["R", "U'"],
|
|
1: ["F'", "U2"]
|
|
},
|
|
UR: {
|
|
0: ["R"],
|
|
1: ["F'", "U'"]
|
|
},
|
|
FR: {
|
|
0: [],
|
|
1: ["F'", "U'", "R'"]
|
|
},
|
|
FL: {
|
|
0: ["F2"],
|
|
1: ["F'", "U", "L"]
|
|
},
|
|
BL: {
|
|
0: ["F2", "L2"],
|
|
1: ["F'", "U", "L'"]
|
|
},
|
|
BR: {
|
|
0: ["R2"],
|
|
1: ["F'", "U'", "R"]
|
|
},
|
|
DF: {
|
|
0: ["R'", "D'"],
|
|
1: ["F"]
|
|
},
|
|
DL: {
|
|
0: ["R'", "D2"],
|
|
1: ["F", "D'"]
|
|
},
|
|
DB: {
|
|
0: ["R'", "D"],
|
|
1: ["F", "D2"]
|
|
},
|
|
DR: {
|
|
0: ["R'"],
|
|
1: ["F", "D"]
|
|
}
|
|
},
|
|
FL: {
|
|
UF: {
|
|
0: ["L'", "U'"],
|
|
1: ["F"]
|
|
},
|
|
UL: {
|
|
0: ["L'"],
|
|
1: ["F", "U"]
|
|
},
|
|
UB: {
|
|
0: ["L'", "U"],
|
|
1: ["F", "U2"]
|
|
},
|
|
UR: {
|
|
0: ["L'", "U2"],
|
|
1: ["F", "U'"]
|
|
},
|
|
FR: {
|
|
0: ["F2"],
|
|
1: ["F", "U'", "R'"]
|
|
},
|
|
FL: {
|
|
0: [],
|
|
1: ["F", "U", "L"]
|
|
},
|
|
BL: {
|
|
0: ["L2"],
|
|
1: ["F", "U", "L'"]
|
|
},
|
|
BR: {
|
|
0: ["F2", "R2"],
|
|
1: ["F", "U'", "R"]
|
|
},
|
|
DF: {
|
|
0: ["L", "D"],
|
|
1: ["F'"]
|
|
},
|
|
DL: {
|
|
0: ["L"],
|
|
1: ["F'", "D'"]
|
|
},
|
|
DB: {
|
|
0: ["L", "D'"],
|
|
1: ["F'", "D2"]
|
|
},
|
|
DR: {
|
|
0: ["L", "D2"],
|
|
1: ["F'", "D"]
|
|
}
|
|
},
|
|
BL: {
|
|
UF: {
|
|
0: ["L", "U'"],
|
|
1: ["B'", "U2"]
|
|
},
|
|
UL: {
|
|
0: ["L"],
|
|
1: ["B'", "U'"]
|
|
},
|
|
UB: {
|
|
0: ["L", "U"],
|
|
1: ["B'"]
|
|
},
|
|
UR: {
|
|
0: ["L", "U2"],
|
|
1: ["B'", "U"]
|
|
},
|
|
FR: {
|
|
0: ["B2", "R2"],
|
|
1: ["B'", "U", "R'"]
|
|
},
|
|
FL: {
|
|
0: ["L2"],
|
|
1: ["B'", "U'", "L"]
|
|
},
|
|
BL: {
|
|
0: [],
|
|
1: ["B'", "U'", "L'"]
|
|
},
|
|
BR: {
|
|
0: ["B2"],
|
|
1: ["B'", "U", "R"]
|
|
},
|
|
DF: {
|
|
0: ["L'", "D"],
|
|
1: ["B", "D2"]
|
|
},
|
|
DL: {
|
|
0: ["L'"],
|
|
1: ["B", "D"]
|
|
},
|
|
DB: {
|
|
0: ["L'", "D'"],
|
|
1: ["B"]
|
|
},
|
|
DR: {
|
|
0: ["L'", "D2"],
|
|
1: ["B", "D'"]
|
|
}
|
|
},
|
|
BR: {
|
|
UF: {
|
|
0: ["R'", "U"],
|
|
1: ["B", "U2"]
|
|
},
|
|
UL: {
|
|
0: ["R'", "U2"],
|
|
1: ["B", "U'"]
|
|
},
|
|
UB: {
|
|
0: ["R'", "U'"],
|
|
1: ["B"]
|
|
},
|
|
UR: {
|
|
0: ["R'"],
|
|
1: ["B", "U"]
|
|
},
|
|
FR: {
|
|
0: ["R2"],
|
|
1: ["B", "U", "R'"]
|
|
},
|
|
FL: {
|
|
0: ["B2", "L2"],
|
|
1: ["B", "U'", "L"]
|
|
},
|
|
BL: {
|
|
0: ["B2"],
|
|
1: ["B", "U'", "L'"]
|
|
},
|
|
BR: {
|
|
0: [],
|
|
1: ["B", "U", "R"]
|
|
},
|
|
DF: {
|
|
0: ["R", "D'"],
|
|
1: ["B'", "D2"]
|
|
},
|
|
DL: {
|
|
0: ["R", "D2"],
|
|
1: ["B'", "D"]
|
|
},
|
|
DB: {
|
|
0: ["R", "D"],
|
|
1: ["B'"]
|
|
},
|
|
DR: {
|
|
0: ["R"],
|
|
1: ["B'", "D'"]
|
|
}
|
|
},
|
|
DF: {
|
|
UF: {
|
|
0: ["F2"],
|
|
1: ["F'", "R", "U"]
|
|
},
|
|
UL: {
|
|
0: ["F2", "U"],
|
|
1: ["F", "L'"]
|
|
},
|
|
UB: {
|
|
0: ["F2", "U2"],
|
|
1: ["F'", "R", "U'"]
|
|
},
|
|
UR: {
|
|
0: ["F2", "U'"],
|
|
1: ["F'", "R"]
|
|
},
|
|
FR: {
|
|
0: ["D", "R"],
|
|
1: ["F'"]
|
|
},
|
|
FL: {
|
|
0: ["D'", "L'"],
|
|
1: ["F"]
|
|
},
|
|
BL: {
|
|
0: ["D'", "L"],
|
|
1: ["D2", "B'"]
|
|
},
|
|
BR: {
|
|
0: ["D", "R'"],
|
|
1: ["D2", "B"]
|
|
},
|
|
DF: {
|
|
0: [],
|
|
1: ["F'", "R'", "D'"]
|
|
},
|
|
DL: {
|
|
0: ["D'"],
|
|
1: ["F", "L"]
|
|
},
|
|
DB: {
|
|
0: ["D2"],
|
|
1: ["F'", "R'", "D"]
|
|
},
|
|
DR: {
|
|
0: ["D"],
|
|
1: ["F'", "R'"]
|
|
}
|
|
},
|
|
DL: {
|
|
UF: {
|
|
0: ["L2", "U'"],
|
|
1: ["L'", "F"]
|
|
},
|
|
UL: {
|
|
0: ["L2"],
|
|
1: ["L'", "F", "U"]
|
|
},
|
|
UB: {
|
|
0: ["L2", "U"],
|
|
1: ["L", "B'"]
|
|
},
|
|
UR: {
|
|
0: ["L2", "U2"],
|
|
1: ["L'", "F", "U'"]
|
|
},
|
|
FR: {
|
|
0: ["D2", "R"],
|
|
1: ["D", "F'"]
|
|
},
|
|
FL: {
|
|
0: ["L'"],
|
|
1: ["D", "F"]
|
|
},
|
|
BL: {
|
|
0: ["L"],
|
|
1: ["D'", "B'"]
|
|
},
|
|
BR: {
|
|
0: ["D2", "R'"],
|
|
1: ["D'", "B"]
|
|
},
|
|
DF: {
|
|
0: ["D"],
|
|
1: ["L'", "F'"]
|
|
},
|
|
DL: {
|
|
0: [],
|
|
1: ["L'", "F'", "D'"]
|
|
},
|
|
DB: {
|
|
0: ["D'"],
|
|
1: ["L", "B"]
|
|
},
|
|
DR: {
|
|
0: ["D2"],
|
|
1: ["L'", "F'", "D"]
|
|
}
|
|
},
|
|
DB: {
|
|
UF: {
|
|
0: ["B2", "U2"],
|
|
1: ["B", "R'", "U"]
|
|
},
|
|
UL: {
|
|
0: ["B2", "U'"],
|
|
1: ["B'", "L"]
|
|
},
|
|
UB: {
|
|
0: ["B2"],
|
|
1: ["B", "R'", "U'"]
|
|
},
|
|
UR: {
|
|
0: ["B2", "U"],
|
|
1: ["B", "R'"]
|
|
},
|
|
FR: {
|
|
0: ["D'", "R"],
|
|
1: ["D2", "F'"]
|
|
},
|
|
FL: {
|
|
0: ["D", "L'"],
|
|
1: ["D2", "F"]
|
|
},
|
|
BL: {
|
|
0: ["D", "L"],
|
|
1: ["B'"]
|
|
},
|
|
BR: {
|
|
0: ["D'", "R'"],
|
|
1: ["B"]
|
|
},
|
|
DF: {
|
|
0: ["D2"],
|
|
1: ["B", "R", "D'"]
|
|
},
|
|
DL: {
|
|
0: ["D"],
|
|
1: ["B'", "L'"]
|
|
},
|
|
DB: {
|
|
0: [],
|
|
1: ["B", "R", "D"]
|
|
},
|
|
DR: {
|
|
0: ["D'"],
|
|
1: ["B", "R"]
|
|
}
|
|
},
|
|
DR: {
|
|
UF: {
|
|
0: ["R2", "U"],
|
|
1: ["R", "F'"]
|
|
},
|
|
UL: {
|
|
0: ["R2", "U2"],
|
|
1: ["R", "F'", "U"]
|
|
},
|
|
UB: {
|
|
0: ["R2", "U'"],
|
|
1: ["R'", "B"]
|
|
},
|
|
UR: {
|
|
0: ["R2"],
|
|
1: ["R", "F'", "U'"]
|
|
},
|
|
FR: {
|
|
0: ["R"],
|
|
1: ["D'", "F'"]
|
|
},
|
|
FL: {
|
|
0: ["D2", "L'"],
|
|
1: ["D'", "F"]
|
|
},
|
|
BL: {
|
|
0: ["D2", "L"],
|
|
1: ["D", "B'"]
|
|
},
|
|
BR: {
|
|
0: ["R'"],
|
|
1: ["D", "B"]
|
|
},
|
|
DF: {
|
|
0: ["D'"],
|
|
1: ["R", "F"]
|
|
},
|
|
DL: {
|
|
0: ["D2"],
|
|
1: ["R", "F", "D'"]
|
|
},
|
|
DB: {
|
|
0: ["D"],
|
|
1: ["R'", "B'"]
|
|
},
|
|
DR: {
|
|
0: [],
|
|
1: ["R", "F", "D"]
|
|
}
|
|
}
|
|
};
|
|
var orderIndexToCubieIndex2 = [
|
|
7,
|
|
17,
|
|
25,
|
|
15,
|
|
3,
|
|
5,
|
|
23,
|
|
21,
|
|
1,
|
|
11,
|
|
19,
|
|
9
|
|
];
|
|
var _Edges_instances, getTurns_fn2;
|
|
var _Edges = class _Edges {
|
|
constructor() {
|
|
__privateAdd(this, _Edges_instances);
|
|
/** @type {Permutation} */
|
|
__publicField(this, "permutation", [..._Edges.order]);
|
|
/** @type {Orientation} */
|
|
__publicField(this, "orientation", [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
|
|
}
|
|
/** @param {TurnBase} turn */
|
|
applyTurn(turn) {
|
|
const appliedPermutation = permutations2[turn];
|
|
const appliedOrientation = orientations2[turn];
|
|
const permutation = [...this.permutation];
|
|
const orientation = [...this.orientation];
|
|
for (let i = 0; i < 12; i++) {
|
|
const newPermutation = appliedPermutation[i];
|
|
const orderIndex = _Edges.order.indexOf(newPermutation);
|
|
this.permutation[i] = permutation[orderIndex];
|
|
const newOrientation = (appliedOrientation[i] + orientation[orderIndex]) % 2;
|
|
this.orientation[i] = /** @type {EO} */
|
|
newOrientation;
|
|
}
|
|
}
|
|
/**
|
|
* @param {number[][][]} uvs
|
|
* @param {import('../ui/rubiks').Rubiks} rubiks
|
|
*/
|
|
applyState(uvs, rubiks) {
|
|
for (let i = 0; i < 12; i++) {
|
|
const turns = __privateMethod(this, _Edges_instances, getTurns_fn2).call(this, i);
|
|
const originIndex = orderIndexToCubieIndex2[_Edges.order.indexOf(this.permutation[i])];
|
|
let sideToUvs = createSideToUvs(originIndex, uvs);
|
|
sideToUvs = transformSidetoUvs(originIndex, sideToUvs, turns);
|
|
const targetIndex = orderIndexToCubieIndex2[i];
|
|
setUvs(targetIndex, rubiks, sideToUvs);
|
|
}
|
|
}
|
|
reset() {
|
|
this.permutation = [..._Edges.order];
|
|
this.orientation = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
|
}
|
|
/** @returns {number[]} */
|
|
encode() {
|
|
let p = [];
|
|
for (let i = 0; i < 6; i++) {
|
|
const p1 = _Edges.order.indexOf(this.permutation[i * 2]);
|
|
const p2 = _Edges.order.indexOf(this.permutation[i * 2 + 1]);
|
|
p.push(
|
|
(p2 << 4) + p1
|
|
);
|
|
}
|
|
let o = 0;
|
|
for (const orientation of this.orientation) {
|
|
o = o << 1;
|
|
o += orientation;
|
|
}
|
|
return [
|
|
...p,
|
|
o >> 0 & 255,
|
|
o >> 8 & 255
|
|
];
|
|
}
|
|
/**
|
|
* @param {number[]} code
|
|
* @returns {boolean}
|
|
*/
|
|
decode(code) {
|
|
for (let i = 0; i < 6; i++) {
|
|
const p1 = code[i] & 15;
|
|
const p2 = code[i] >> 4 & 15;
|
|
if (p1 >= 12 || p2 >= 12) {
|
|
return false;
|
|
}
|
|
this.permutation[i * 2] = _Edges.order[p1];
|
|
this.permutation[i * 2 + 1] = _Edges.order[p2];
|
|
}
|
|
let o = code[6] + (code[7] << 8);
|
|
for (let i = 11; i >= 0; i--) {
|
|
this.orientation[i] = /** @type {EO} */
|
|
o & 1;
|
|
o = o >> 1;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
_Edges_instances = new WeakSet();
|
|
/**
|
|
* @param {number} index
|
|
* @returns {Turn[]}
|
|
*/
|
|
getTurns_fn2 = function(index) {
|
|
const start = _Edges.order[index];
|
|
const permutation = this.permutation[index];
|
|
const orientation = this.orientation[index];
|
|
return map2[permutation][start][orientation];
|
|
};
|
|
/** @type {Permutation} */
|
|
__publicField(_Edges, "order", ["UF", "UL", "UB", "UR", "FR", "FL", "BL", "BR", "DF", "DL", "DB", "DR"]);
|
|
var Edges = _Edges;
|
|
|
|
// node_modules/rubiks-js/src/math/utils.js
|
|
var mod = (a, b) => {
|
|
return (a % b + b) % b;
|
|
};
|
|
var lerp = (a, b, t) => {
|
|
return a + (b - a) * t;
|
|
};
|
|
var clamp = (x, min, max) => {
|
|
return Math.min(Math.max(x, min), max);
|
|
};
|
|
|
|
// node_modules/rubiks-js/src/state/centers.js
|
|
var orderIndexToCubieIndex3 = [
|
|
12,
|
|
14,
|
|
10,
|
|
16,
|
|
4,
|
|
22
|
|
];
|
|
var _Centers = class _Centers {
|
|
constructor() {
|
|
/** @type {Orientation} */
|
|
__publicField(this, "orientation", [0, 0, 0, 0, 0, 0]);
|
|
}
|
|
/** @param {TurnBase} turn */
|
|
applyTurn(turn) {
|
|
const index = _Centers.order.indexOf(turn);
|
|
this.orientation[index] = /** @type {CO} */
|
|
mod(this.orientation[index] + 1, 4);
|
|
}
|
|
/**
|
|
* @param {number[][][]} uvs
|
|
* @param {import('../ui/rubiks').Rubiks} rubiks
|
|
*/
|
|
applyState(uvs, rubiks) {
|
|
for (let side = 0; side < 6; side++) {
|
|
const uv = uvs[side][4];
|
|
const offset = this.orientation[side] * 2;
|
|
const cubieIndex = orderIndexToCubieIndex3[side];
|
|
const facelet = rubiks.cubies[cubieIndex].getFaceletOfSide(side);
|
|
facelet.uvs = [];
|
|
for (let i = 0; i < 8; i++) {
|
|
facelet.uvs[i] = uv[mod(offset + i, 8)];
|
|
}
|
|
}
|
|
}
|
|
reset() {
|
|
this.orientation = [0, 0, 0, 0, 0, 0];
|
|
}
|
|
/** @returns {number[]} */
|
|
encode() {
|
|
let o = 0;
|
|
for (const orientation of this.orientation) {
|
|
o = o << 2;
|
|
o += orientation;
|
|
}
|
|
return [
|
|
o >> 0 & 255,
|
|
o >> 8 & 255
|
|
];
|
|
}
|
|
/** @param {number[]} code */
|
|
decode(code) {
|
|
let o = code[0] + (code[1] << 8);
|
|
for (let i = 5; i >= 0; i--) {
|
|
this.orientation[i] = /** @type {CO} */
|
|
o & 3;
|
|
o = o >> 2;
|
|
}
|
|
}
|
|
};
|
|
/** @type {Permutation} */
|
|
__publicField(_Centers, "order", ["R", "L", "D", "U", "F", "B"]);
|
|
var Centers = _Centers;
|
|
|
|
// node_modules/rubiks-js/src/converter.js
|
|
var axisToTurn = [
|
|
["R", "L", false],
|
|
["D", "U", true],
|
|
["F", "B", false]
|
|
];
|
|
var convertAiaToTurn = (aia) => {
|
|
if (aia.index === 1) {
|
|
throw new Error("Cannot convert middle turns");
|
|
}
|
|
let [a, b, invert] = axisToTurn[aia.axis];
|
|
const turn = aia.index === 0 ? a : b;
|
|
if (aia.angle === 2) {
|
|
return `${turn}2`;
|
|
}
|
|
if (aia.index === 2) {
|
|
invert = !invert;
|
|
}
|
|
if (aia.angle === 3 && !invert || aia.angle === 1 && invert) {
|
|
return `${turn}'`;
|
|
}
|
|
return turn;
|
|
};
|
|
var turnToAia = {
|
|
R: [0, 0, false],
|
|
L: [0, 2, false],
|
|
D: [1, 0, true],
|
|
U: [1, 2, true],
|
|
F: [2, 0, false],
|
|
B: [2, 2, false]
|
|
};
|
|
var convertTurnToAia = (turn) => {
|
|
const base = (
|
|
/** @type {TurnBase} */
|
|
turn[0]
|
|
);
|
|
const [axis, index, invert] = turnToAia[base];
|
|
if (turn.endsWith("2")) {
|
|
return { axis, index, angle: 2 };
|
|
}
|
|
let prime = turn.endsWith("'");
|
|
if (invert) {
|
|
prime = !prime;
|
|
}
|
|
let angle = 3;
|
|
if (index === 0 && !prime || index === 2 && prime) {
|
|
angle = 1;
|
|
}
|
|
return { axis, index, angle };
|
|
};
|
|
var convertTurnToTurnBase = (turn) => {
|
|
const base = (
|
|
/** @type {TurnBase} */
|
|
turn[0]
|
|
);
|
|
if (turn.endsWith("2")) {
|
|
return [base, base];
|
|
}
|
|
if (turn.endsWith("'")) {
|
|
return [base, base, base];
|
|
}
|
|
return [base];
|
|
};
|
|
|
|
// node_modules/rubiks-js/src/ui/uvs.js
|
|
var uvsTransformers = {
|
|
identity: (uvs) => [...uvs],
|
|
flipH: (uvs) => [uvs[6], uvs[7], uvs[4], uvs[5], uvs[2], uvs[3], uvs[0], uvs[1]],
|
|
flipV: (uvs) => [uvs[2], uvs[3], uvs[0], uvs[1], uvs[6], uvs[7], uvs[4], uvs[5]],
|
|
rotateCC: (uvs) => [uvs[6], uvs[7], uvs[0], uvs[1], uvs[2], uvs[3], uvs[4], uvs[5]],
|
|
rotateC: (uvs) => [uvs[2], uvs[3], uvs[4], uvs[5], uvs[6], uvs[7], uvs[0], uvs[1]],
|
|
rotate2: (uvs) => [uvs[4], uvs[5], uvs[6], uvs[7], uvs[0], uvs[1], uvs[2], uvs[3]],
|
|
rotateCFlipH: (uvs) => [uvs[0], uvs[1], uvs[6], uvs[7], uvs[4], uvs[5], uvs[2], uvs[3]]
|
|
};
|
|
var uvsTransformerPresets = {
|
|
flipV12: {
|
|
1: uvsTransformers.flipV,
|
|
2: uvsTransformers.flipV,
|
|
3: uvsTransformers.identity
|
|
},
|
|
flipV23: {
|
|
1: uvsTransformers.identity,
|
|
2: uvsTransformers.flipV,
|
|
3: uvsTransformers.flipV
|
|
},
|
|
flipH12: {
|
|
1: uvsTransformers.flipH,
|
|
2: uvsTransformers.flipH,
|
|
3: uvsTransformers.identity
|
|
},
|
|
flipH23: {
|
|
1: uvsTransformers.identity,
|
|
2: uvsTransformers.flipH,
|
|
3: uvsTransformers.flipH
|
|
},
|
|
rcfhFvRcc: {
|
|
1: uvsTransformers.rotateCFlipH,
|
|
2: uvsTransformers.flipV,
|
|
3: uvsTransformers.rotateCC
|
|
},
|
|
rcFvRcfh: {
|
|
1: uvsTransformers.rotateC,
|
|
2: uvsTransformers.flipV,
|
|
3: uvsTransformers.rotateCFlipH
|
|
},
|
|
rcFhRcfh: {
|
|
1: uvsTransformers.rotateC,
|
|
2: uvsTransformers.flipH,
|
|
3: uvsTransformers.rotateCFlipH
|
|
},
|
|
rcfhFhRcc: {
|
|
1: uvsTransformers.rotateCFlipH,
|
|
2: uvsTransformers.flipH,
|
|
3: uvsTransformers.rotateCC
|
|
},
|
|
rcR2Rcc: {
|
|
1: uvsTransformers.rotateC,
|
|
2: uvsTransformers.rotate2,
|
|
3: uvsTransformers.rotateCC
|
|
},
|
|
rccR2Rc: {
|
|
1: uvsTransformers.rotateCC,
|
|
2: uvsTransformers.rotate2,
|
|
3: uvsTransformers.rotateC
|
|
}
|
|
};
|
|
var cubiesShiftMapper = {
|
|
0: {
|
|
0: [0, 3, 6, 15, 24, 21, 18, 9],
|
|
2: [2, 5, 8, 17, 26, 23, 20, 11]
|
|
},
|
|
1: {
|
|
0: [0, 1, 2, 11, 20, 19, 18, 9],
|
|
2: [6, 7, 8, 17, 26, 25, 24, 15]
|
|
},
|
|
2: {
|
|
0: [0, 1, 2, 5, 8, 7, 6, 3],
|
|
2: [18, 19, 20, 23, 26, 25, 24, 21]
|
|
}
|
|
};
|
|
var sidesShiftMapper = [
|
|
[2, 5, 3, 4],
|
|
[0, 5, 1, 4],
|
|
[0, 3, 1, 2]
|
|
];
|
|
|
|
// node_modules/rubiks-js/src/state/index.js
|
|
var _corners, _edges, _centers, _trackCenters;
|
|
var State = class {
|
|
/** @param {boolean} trackCenters */
|
|
constructor(trackCenters) {
|
|
__privateAdd(this, _corners, new Corners());
|
|
__privateAdd(this, _edges, new Edges());
|
|
__privateAdd(this, _centers, new Centers());
|
|
/** @type {boolean} */
|
|
__privateAdd(this, _trackCenters);
|
|
__publicField(this, "stateInfo", new StateInfo(this));
|
|
__privateSet(this, _trackCenters, trackCenters);
|
|
}
|
|
/** @param {Turn} turn */
|
|
applyTurn(turn) {
|
|
const baseTurns = convertTurnToTurnBase(turn);
|
|
for (const base of baseTurns) {
|
|
__privateGet(this, _corners).applyTurn(base);
|
|
__privateGet(this, _edges).applyTurn(base);
|
|
if (__privateGet(this, _trackCenters)) {
|
|
__privateGet(this, _centers).applyTurn(base);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* @param {number[][][]} uvs
|
|
* @param {import('../ui/rubiks').Rubiks} rubiks
|
|
*/
|
|
applyState(uvs, rubiks) {
|
|
__privateGet(this, _corners).applyState(uvs, rubiks);
|
|
__privateGet(this, _edges).applyState(uvs, rubiks);
|
|
if (__privateGet(this, _trackCenters)) {
|
|
__privateGet(this, _centers).applyState(uvs, rubiks);
|
|
}
|
|
}
|
|
/** @returns {string} */
|
|
encode() {
|
|
const code = [];
|
|
code.push(...__privateGet(this, _corners).encode());
|
|
code.push(...__privateGet(this, _edges).encode());
|
|
if (__privateGet(this, _trackCenters)) {
|
|
code.push(...__privateGet(this, _centers).encode());
|
|
}
|
|
const array = new Uint8Array(code);
|
|
return btoa(String.fromCharCode(...array));
|
|
}
|
|
/**
|
|
* @param {string} str
|
|
* @returns {boolean}
|
|
*/
|
|
decode(str) {
|
|
const data = atob(str);
|
|
if (data.length !== (__privateGet(this, _trackCenters) ? 15 : 13)) {
|
|
return false;
|
|
}
|
|
const code = [];
|
|
for (let i = 0; i < data.length; i++) {
|
|
code.push(data.charCodeAt(i));
|
|
}
|
|
const corners = __privateGet(this, _corners);
|
|
const cp = [...corners.permutation];
|
|
const co = [...corners.orientation];
|
|
if (!corners.decode(code.slice(0, 5))) {
|
|
corners.permutation = cp;
|
|
corners.orientation = co;
|
|
return false;
|
|
}
|
|
const edges = __privateGet(this, _edges);
|
|
const ep = [...edges.permutation];
|
|
const eo = [...edges.orientation];
|
|
if (!edges.decode(code.slice(5, 13))) {
|
|
corners.permutation = cp;
|
|
corners.orientation = co;
|
|
edges.permutation = ep;
|
|
edges.orientation = eo;
|
|
return false;
|
|
}
|
|
if (__privateGet(this, _trackCenters)) {
|
|
__privateGet(this, _centers).decode(code.slice(13));
|
|
}
|
|
return true;
|
|
}
|
|
reset() {
|
|
__privateGet(this, _corners).reset();
|
|
__privateGet(this, _edges).reset();
|
|
__privateGet(this, _centers).reset();
|
|
}
|
|
};
|
|
_corners = new WeakMap();
|
|
_edges = new WeakMap();
|
|
_centers = new WeakMap();
|
|
_trackCenters = new WeakMap();
|
|
var _state;
|
|
var StateInfo = class {
|
|
/** @param {State} state */
|
|
constructor(state) {
|
|
/** @type {State} */
|
|
__privateAdd(this, _state);
|
|
__privateSet(this, _state, state);
|
|
}
|
|
/**
|
|
* @returns {string} base64 encoded, can be used in the setState method
|
|
*/
|
|
toString() {
|
|
return __privateGet(this, _state).encode();
|
|
}
|
|
};
|
|
_state = new WeakMap();
|
|
var uvsTransformers2 = {
|
|
0: {
|
|
0: uvsTransformerPresets.rcR2Rcc,
|
|
1: uvsTransformerPresets.rcR2Rcc,
|
|
2: uvsTransformerPresets.flipV12,
|
|
3: uvsTransformerPresets.flipV12,
|
|
4: uvsTransformerPresets.flipV23,
|
|
5: uvsTransformerPresets.flipV23
|
|
},
|
|
1: {
|
|
0: uvsTransformerPresets.rcFvRcfh,
|
|
1: uvsTransformerPresets.rcFvRcfh,
|
|
2: uvsTransformerPresets.rcR2Rcc,
|
|
3: uvsTransformerPresets.rcR2Rcc,
|
|
4: uvsTransformerPresets.rcfhFhRcc,
|
|
5: uvsTransformerPresets.rcfhFhRcc
|
|
},
|
|
2: {
|
|
0: uvsTransformerPresets.flipH12,
|
|
1: uvsTransformerPresets.flipH12,
|
|
2: uvsTransformerPresets.flipH23,
|
|
3: uvsTransformerPresets.flipH23,
|
|
4: uvsTransformerPresets.rcR2Rcc,
|
|
5: uvsTransformerPresets.rcR2Rcc
|
|
}
|
|
};
|
|
var createSideToUvs = (originIndex, uvs) => {
|
|
const pos = indexToPosition(originIndex);
|
|
const sideToUvs = {};
|
|
for (let side = 0; side < 6; side++) {
|
|
const inside = isInside(side, originIndex);
|
|
if (inside) {
|
|
continue;
|
|
}
|
|
sideToUvs[side] = positionToUvs(pos, side, uvs);
|
|
}
|
|
return sideToUvs;
|
|
};
|
|
var transformSidetoUvs = (originIndex, sideToUvs, turns) => {
|
|
for (const turn of turns) {
|
|
let { axis, index, angle } = convertTurnToAia(turn);
|
|
const innerSide = axis * 2 + Math.sign(index);
|
|
const newSideToUvs = {};
|
|
for (const [sideStr, uvs] of Object.entries(sideToUvs)) {
|
|
const side = parseInt(sideStr);
|
|
const transformer = uvsTransformers2[axis][side][angle];
|
|
if (side === innerSide) {
|
|
newSideToUvs[innerSide] = transformer(uvs);
|
|
continue;
|
|
}
|
|
const sideIndex = sidesShiftMapper[axis].indexOf(side);
|
|
const newSide = sidesShiftMapper[axis][mod(sideIndex - angle, 4)];
|
|
newSideToUvs[newSide] = transformer(uvs);
|
|
}
|
|
const mapperIndex = cubiesShiftMapper[axis][index].indexOf(originIndex);
|
|
originIndex = cubiesShiftMapper[axis][index][mod(mapperIndex + angle * 2, 8)];
|
|
sideToUvs = newSideToUvs;
|
|
}
|
|
return sideToUvs;
|
|
};
|
|
var setUvs = (targetIndex, rubiks, sideToUvs) => {
|
|
const cubie = rubiks.cubies[targetIndex];
|
|
for (const facelet of cubie.facelets) {
|
|
facelet.uvs = sideToUvs[facelet.side];
|
|
}
|
|
};
|
|
|
|
export {
|
|
mod,
|
|
lerp,
|
|
clamp,
|
|
convertAiaToTurn,
|
|
uvsTransformerPresets,
|
|
sidesShiftMapper,
|
|
State,
|
|
StateInfo,
|
|
createSideToUvs,
|
|
transformSidetoUvs,
|
|
setUvs
|
|
};
|
|
//# sourceMappingURL=chunk-YIK32INT.js.map
|