1395 lines
38 KiB
JavaScript
1395 lines
38 KiB
JavaScript
|
/*
|
||
|
|
|
||
|
|
scramble_333.js
|
||
|
|
|
||
|
|
3x3x3 Solver / Scramble Generator in Javascript.
|
||
|
|
|
||
|
|
The core 3x3x3 code is from a min2phase solver by Shuang Chen.
|
||
|
|
Compiled to Javascript using GWT.
|
||
|
|
(There may be a lot of redundant code right now, but it's still really fast.)
|
||
|
|
|
||
|
|
*/
|
||
|
|
"use strict";
|
||
|
|
|
||
|
|
var scramble_333 = (function(getNPerm, get8Perm, setNPerm, set8Perm, getNParity, getPruning, Cnk, fact, rn, rndEl) {
|
||
|
|
|
||
|
|
var Ux1 = 0, Ux2 = 1, Ux3 = 2,
|
||
|
|
Rx1 = 3, Rx2 = 4, Rx3 = 5,
|
||
|
|
Fx1 = 6, Fx2 = 7, Fx3 = 8,
|
||
|
|
Dx1 = 9, Dx2 = 10, Dx3 = 11,
|
||
|
|
Lx1 = 12, Lx2 = 13, Lx3 = 14,
|
||
|
|
Bx1 = 15, Bx2 = 16, Bx3 = 17;
|
||
|
|
|
||
|
|
function createArray(length1, length2) {
|
||
|
|
var result, i;
|
||
|
|
result = [];
|
||
|
|
if (length2 != undefined) {
|
||
|
|
for (i = 0; i < length1; i++) {
|
||
|
|
result[i] = [];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
function CoordCube_$clinit() {
|
||
|
|
UDSliceMove = createArray(495, 18);
|
||
|
|
TwistMove = createArray(324, 18);
|
||
|
|
FlipMove = createArray(336, 18);
|
||
|
|
UDSliceConj = createArray(495, 8);
|
||
|
|
UDSliceTwistPrun = createArray(20048);
|
||
|
|
UDSliceFlipPrun = createArray(20790);
|
||
|
|
CPermMove = createArray(2768, 18);
|
||
|
|
EPermMove = createArray(2768, 10);
|
||
|
|
MPermMove = createArray(24, 10);
|
||
|
|
MPermConj = createArray(24, 16);
|
||
|
|
MCPermPrun = createArray(8304);
|
||
|
|
MEPermPrun = createArray(8304);
|
||
|
|
}
|
||
|
|
|
||
|
|
function initMPermMoveConj() {
|
||
|
|
var c, d, i, j;
|
||
|
|
c = new CubieCube;
|
||
|
|
d = new CubieCube;
|
||
|
|
for (i = 0; i < 24; ++i) {
|
||
|
|
setComb(c.ep, i << 9);
|
||
|
|
for (j = 0; j < 10; ++j) {
|
||
|
|
EdgeMult(c, moveCube[ud2std[j]], d);
|
||
|
|
MPermMove[i][j] = getComb(d.ep, 8) >> 9;
|
||
|
|
}
|
||
|
|
for (j = 0; j < 16; ++j) {
|
||
|
|
EdgeConjugate(c, SymInv[j], d);
|
||
|
|
MPermConj[i][j] = getComb(d.ep, 8) >> 9;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function initRawSymPrun(PrunTable, INV_DEPTH, RawMove, RawConj, SymMove, SymState, SymSwitch, moveMap, SYM_SHIFT) {
|
||
|
|
var N_MOVES, N_RAW, N_SIZE, N_SYM, SYM_MASK, check, depth, done, end, i, idx, idxx, inv, j, m, raw, rawx, select, sym, symState, symx, val, fill, len;
|
||
|
|
SYM_MASK = (1 << SYM_SHIFT) - 1;
|
||
|
|
N_RAW = RawMove.length;
|
||
|
|
N_SYM = SymMove.length;
|
||
|
|
N_SIZE = N_RAW * N_SYM;
|
||
|
|
N_MOVES = RawMove[0].length;
|
||
|
|
for (i = 0, len = (N_RAW * N_SYM + 7) >> 3; i < len; ++i) {
|
||
|
|
PrunTable[i] = -1;
|
||
|
|
}
|
||
|
|
PrunTable[0] ^= 15;
|
||
|
|
depth = 0;
|
||
|
|
done = 1;
|
||
|
|
while (done < N_SIZE) {
|
||
|
|
inv = depth > INV_DEPTH;
|
||
|
|
select = inv ? 15 : depth;
|
||
|
|
check = inv ? depth : 15;
|
||
|
|
++depth;
|
||
|
|
fill = depth ^ 15;
|
||
|
|
for (i = 0; i < N_SIZE;) {
|
||
|
|
val = PrunTable[i >> 3];
|
||
|
|
if (!inv && val == -1) {
|
||
|
|
i += 8;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
for (end = i + 8 < N_SIZE ? i + 8 : N_SIZE; i < end; ++i, val >>= 4) {
|
||
|
|
if ((val & 15) != select) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
raw = i % N_RAW;
|
||
|
|
sym = ~~(i / N_RAW);
|
||
|
|
for (m = 0; m < N_MOVES; ++m) {
|
||
|
|
symx = SymMove[sym][moveMap == null ? m : moveMap[m]];
|
||
|
|
rawx = RawConj[RawMove[raw][m] & 511][symx & SYM_MASK];
|
||
|
|
symx >>>= SYM_SHIFT;
|
||
|
|
idx = symx * N_RAW + rawx;
|
||
|
|
if ((PrunTable[idx >> 3] >> ((idx & 7) << 2) & 15) != check) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
++done;
|
||
|
|
if (inv) {
|
||
|
|
PrunTable[i >> 3] ^= fill << ((i & 7) << 2);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
PrunTable[idx >> 3] ^= fill << ((idx & 7) << 2);
|
||
|
|
for (j = 1, symState = SymState[symx];
|
||
|
|
(symState >>= 1) != 0; ++j) {
|
||
|
|
if ((symState & 1) == 1) {
|
||
|
|
idxx = symx * N_RAW + RawConj[rawx][j ^ (SymSwitch == null ? 0 : SymSwitch[j])];
|
||
|
|
if ((PrunTable[idxx >> 3] >> ((idxx & 7) << 2) & 15) == 15) {
|
||
|
|
PrunTable[idxx >> 3] ^= fill << ((idxx & 7) << 2);
|
||
|
|
++done;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// console.log(done);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function initMoveTable(MoveTable, SIZE, S2RArray, setIdx, getIdx, isEdge, isPhase2) {
|
||
|
|
var c, d, i, j, N_MOVES = isPhase2 ? 10 : 18;
|
||
|
|
c = new CubieCube;
|
||
|
|
d = new CubieCube;
|
||
|
|
for (i = 0; i < SIZE; ++i) {
|
||
|
|
setIdx(c, S2RArray[i]);
|
||
|
|
for (j = 0; j < N_MOVES; ++j) {
|
||
|
|
(isEdge ? EdgeMult : CornMult)(c, moveCube[isPhase2 ? ud2std[j] : j], d);
|
||
|
|
MoveTable[i][j] = getIdx(d);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function initUDSliceMoveConj() {
|
||
|
|
var c, cx, d, i, j, k, udslice;
|
||
|
|
c = new CubieCube;
|
||
|
|
d = new CubieCube;
|
||
|
|
for (i = 0; i < 495; ++i) {
|
||
|
|
setComb(c.ep, i);
|
||
|
|
for (j = 0; j < 18; j += 3) {
|
||
|
|
EdgeMult(c, moveCube[j], d);
|
||
|
|
UDSliceMove[i][j] = getComb(d.ep, 8);
|
||
|
|
}
|
||
|
|
for (j = 0; j < 16; j += 2) {
|
||
|
|
EdgeConjugate(c, SymInv[j], d);
|
||
|
|
UDSliceConj[i][j >>> 1] = getComb(d.ep, 8) & 511;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (i = 0; i < 495; ++i) {
|
||
|
|
for (j = 0; j < 18; j += 3) {
|
||
|
|
udslice = UDSliceMove[i][j];
|
||
|
|
for (k = 1; k < 3; ++k) {
|
||
|
|
cx = UDSliceMove[udslice & 511][j];
|
||
|
|
udslice = permMult[udslice >>> 9][cx >>> 9] << 9 | cx & 511;
|
||
|
|
UDSliceMove[i][j + k] = udslice;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var CPermMove, EPermMove, FlipMove, MCPermPrun, MEPermPrun, MPermConj, MPermMove, TwistMove, UDSliceConj, UDSliceFlipPrun, UDSliceMove, UDSliceTwistPrun;
|
||
|
|
|
||
|
|
function CubieCube_$clinit() {
|
||
|
|
CubeSym = createArray(16);
|
||
|
|
moveCube = createArray(18);
|
||
|
|
SymInv = createArray(16);
|
||
|
|
SymMult = createArray(16, 16);
|
||
|
|
SymMove = createArray(16, 18);
|
||
|
|
Sym8Mult = createArray(8, 8);
|
||
|
|
Sym8Move = createArray(8, 18);
|
||
|
|
Sym8MultInv = createArray(8, 8);
|
||
|
|
SymMoveUD = createArray(16, 10);
|
||
|
|
FlipS2R = createArray(336);
|
||
|
|
TwistS2R = createArray(324);
|
||
|
|
epermS2R = createArray(2768);
|
||
|
|
e2c = [0, 0, 0, 0, 1, 3, 1, 3, 1, 3, 1, 3, 0, 0, 0, 0];
|
||
|
|
MtoEPerm = createArray(70, 576);
|
||
|
|
SymStateTwist = createArray(324);
|
||
|
|
SymStateFlip = createArray(336);
|
||
|
|
SymStatePerm = createArray(2768);
|
||
|
|
urf1 = new CubieCube1(2531, 1373, 67026819, 1367);
|
||
|
|
urf2 = new CubieCube1(2089, 1906, 322752913, 2040);
|
||
|
|
urfMove = [
|
||
|
|
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17],
|
||
|
|
[6, 7, 8, 0, 1, 2, 3, 4, 5, 15, 16, 17, 9, 10, 11, 12, 13, 14],
|
||
|
|
[3, 4, 5, 6, 7, 8, 0, 1, 2, 12, 13, 14, 15, 16, 17, 9, 10, 11],
|
||
|
|
[2, 1, 0, 5, 4, 3, 8, 7, 6, 11, 10, 9, 14, 13, 12, 17, 16, 15],
|
||
|
|
[8, 7, 6, 2, 1, 0, 5, 4, 3, 17, 16, 15, 11, 10, 9, 14, 13, 12],
|
||
|
|
[5, 4, 3, 8, 7, 6, 2, 1, 0, 14, 13, 12, 17, 16, 15, 11, 10, 9]
|
||
|
|
];
|
||
|
|
}
|
||
|
|
|
||
|
|
function CubieCube_$$init(obj) {
|
||
|
|
obj.cp = [0, 1, 2, 3, 4, 5, 6, 7];
|
||
|
|
obj.co = [0, 0, 0, 0, 0, 0, 0, 0];
|
||
|
|
obj.ep = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
|
||
|
|
obj.eo = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
||
|
|
}
|
||
|
|
|
||
|
|
function $copy(obj, c) {
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 8; ++i) {
|
||
|
|
obj.cp[i] = c.cp[i];
|
||
|
|
obj.co[i] = c.co[i];
|
||
|
|
}
|
||
|
|
for (i = 0; i < 12; ++i) {
|
||
|
|
obj.ep[i] = c.ep[i];
|
||
|
|
obj.eo[i] = c.eo[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function $getCPermSym(obj) {
|
||
|
|
var idx, k;
|
||
|
|
if (epermR2S !== null) {
|
||
|
|
idx = epermR2S[get8Perm(obj.cp)];
|
||
|
|
return idx ^ e2c[idx & 15];
|
||
|
|
}
|
||
|
|
obj.temps || (obj.temps = new CubieCube);
|
||
|
|
for (k = 0; k < 16; ++k) {
|
||
|
|
cornConjugate(obj, SymInv[k], obj.temps);
|
||
|
|
idx = binarySearch(epermS2R, get8Perm(obj.temps.cp));
|
||
|
|
if (idx != 65535) {
|
||
|
|
return (idx << 4 | k);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
function $getEPermSym(obj) {
|
||
|
|
return epermR2S[get8Perm(obj.ep)];
|
||
|
|
}
|
||
|
|
|
||
|
|
function $getFlip(obj) {
|
||
|
|
var i, idx;
|
||
|
|
idx = 0;
|
||
|
|
for (i = 0; i < 11; ++i) {
|
||
|
|
idx <<= 1;
|
||
|
|
idx |= obj.eo[i];
|
||
|
|
}
|
||
|
|
return idx;
|
||
|
|
}
|
||
|
|
|
||
|
|
function $getFlipSym(obj) {
|
||
|
|
return FlipR2S[$getFlip(obj)];
|
||
|
|
}
|
||
|
|
|
||
|
|
function $getTwist(obj) {
|
||
|
|
var i, idx;
|
||
|
|
idx = 0;
|
||
|
|
for (i = 0; i < 7; ++i) {
|
||
|
|
idx *= 3;
|
||
|
|
idx += obj.co[i];
|
||
|
|
}
|
||
|
|
return idx;
|
||
|
|
}
|
||
|
|
|
||
|
|
function $getTwistSym(obj) {
|
||
|
|
return TwistR2S[$getTwist(obj)];
|
||
|
|
}
|
||
|
|
|
||
|
|
function $invCubieCube(obj) {
|
||
|
|
var corn, edge, ori;
|
||
|
|
for (edge = 0; edge < 12; ++edge)
|
||
|
|
obj.temps.ep[obj.ep[edge]] = edge;
|
||
|
|
for (edge = 0; edge < 12; ++edge)
|
||
|
|
obj.temps.eo[edge] = obj.eo[obj.temps.ep[edge]];
|
||
|
|
for (corn = 0; corn < 8; ++corn)
|
||
|
|
obj.temps.cp[obj.cp[corn]] = corn;
|
||
|
|
for (corn = 0; corn < 8; ++corn) {
|
||
|
|
ori = obj.co[obj.temps.cp[corn]];
|
||
|
|
obj.temps.co[corn] = -ori;
|
||
|
|
obj.temps.co[corn] < 0 && (obj.temps.co[corn] = obj.temps.co[corn] + 3);
|
||
|
|
}
|
||
|
|
$copy(obj, obj.temps);
|
||
|
|
}
|
||
|
|
|
||
|
|
function $setCPerm(obj, idx) {
|
||
|
|
set8Perm(obj.cp, idx);
|
||
|
|
}
|
||
|
|
|
||
|
|
function $setEPerm(obj, idx) {
|
||
|
|
set8Perm(obj.ep, idx);
|
||
|
|
}
|
||
|
|
|
||
|
|
function $setFlip(obj, idx) {
|
||
|
|
var i, parity;
|
||
|
|
parity = 0;
|
||
|
|
for (i = 10; i >= 0; --i) {
|
||
|
|
parity ^= obj.eo[i] = (idx & 1);
|
||
|
|
idx >>= 1;
|
||
|
|
}
|
||
|
|
obj.eo[11] = parity;
|
||
|
|
}
|
||
|
|
|
||
|
|
function $setTwist(obj, idx) {
|
||
|
|
var i, twst;
|
||
|
|
twst = 0;
|
||
|
|
for (i = 6; i >= 0; --i) {
|
||
|
|
twst += obj.co[i] = idx % 3;
|
||
|
|
idx = ~~(idx / 3);
|
||
|
|
}
|
||
|
|
obj.co[7] = (15 - twst) % 3;
|
||
|
|
}
|
||
|
|
|
||
|
|
function cornConjugate(a, idx, b) {
|
||
|
|
var corn, oriA, oriB, s, sinv;
|
||
|
|
sinv = CubeSym[SymInv[idx]];
|
||
|
|
s = CubeSym[idx];
|
||
|
|
for (corn = 0; corn < 8; ++corn) {
|
||
|
|
b.cp[corn] = sinv.cp[a.cp[s.cp[corn]]];
|
||
|
|
oriA = sinv.co[a.cp[s.cp[corn]]];
|
||
|
|
oriB = a.co[s.cp[corn]];
|
||
|
|
b.co[corn] = oriA < 3 ? oriB : (3 - oriB) % 3;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function CornMult(a, b, prod) {
|
||
|
|
var corn, ori, oriA, oriB;
|
||
|
|
for (corn = 0; corn < 8; ++corn) {
|
||
|
|
prod.cp[corn] = a.cp[b.cp[corn]];
|
||
|
|
oriA = a.co[b.cp[corn]];
|
||
|
|
oriB = b.co[corn];
|
||
|
|
ori = oriA;
|
||
|
|
ori += oriA < 3 ? oriB : 6 - oriB;
|
||
|
|
ori %= 3;
|
||
|
|
((oriA >= 3) !== (oriB >= 3)) && (ori += 3);
|
||
|
|
prod.co[corn] = ori;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function CubieCube() {
|
||
|
|
CubieCube_$$init(this);
|
||
|
|
}
|
||
|
|
|
||
|
|
function CubieCube1(cperm, twist, eperm, flip) {
|
||
|
|
CubieCube_$$init(this);
|
||
|
|
set8Perm(this.cp, cperm);
|
||
|
|
$setTwist(this, twist);
|
||
|
|
setNPerm(this.ep, eperm, 12);
|
||
|
|
$setFlip(this, flip);
|
||
|
|
}
|
||
|
|
|
||
|
|
function CubieCube2(c) {
|
||
|
|
CubieCube_$$init(this);
|
||
|
|
$copy(this, c);
|
||
|
|
}
|
||
|
|
|
||
|
|
function EdgeConjugate(a, idx, b) {
|
||
|
|
var ed, s, sinv;
|
||
|
|
sinv = CubeSym[SymInv[idx]];
|
||
|
|
s = CubeSym[idx];
|
||
|
|
for (ed = 0; ed < 12; ++ed) {
|
||
|
|
b.ep[ed] = sinv.ep[a.ep[s.ep[ed]]];
|
||
|
|
b.eo[ed] = s.eo[ed] ^ a.eo[s.ep[ed]] ^ sinv.eo[a.ep[s.ep[ed]]];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function EdgeMult(a, b, prod) {
|
||
|
|
var ed;
|
||
|
|
for (ed = 0; ed < 12; ++ed) {
|
||
|
|
prod.ep[ed] = a.ep[b.ep[ed]];
|
||
|
|
prod.eo[ed] = b.eo[ed] ^ a.eo[b.ep[ed]];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function initFlipSym2Raw() {
|
||
|
|
var c, count, d, i, idx, occ, s;
|
||
|
|
c = new CubieCube;
|
||
|
|
d = new CubieCube;
|
||
|
|
occ = createArray(64);
|
||
|
|
count = 0;
|
||
|
|
for (i = 0; i < 64; occ[i++] = 0) {}
|
||
|
|
FlipR2S = createArray(2048);
|
||
|
|
for (i = 0; i < 2048; ++i) {
|
||
|
|
if ((occ[i >> 5] & 1 << (i & 31)) == 0) {
|
||
|
|
$setFlip(c, i);
|
||
|
|
for (s = 0; s < 16; s += 2) {
|
||
|
|
EdgeConjugate(c, s, d);
|
||
|
|
idx = $getFlip(d);
|
||
|
|
idx == i && (SymStateFlip[count] |= 1 << (s >> 1));
|
||
|
|
occ[idx >> 5] |= 1 << (idx & 31);
|
||
|
|
FlipR2S[idx] = count << 3 | s >> 1;
|
||
|
|
}
|
||
|
|
FlipS2R[count++] = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function initMove() {
|
||
|
|
var a, p;
|
||
|
|
moveCube[0] = new CubieCube1(15120, 0, 119750400, 0);
|
||
|
|
moveCube[3] = new CubieCube1(21021, 1494, 323403417, 0);
|
||
|
|
moveCube[6] = new CubieCube1(8064, 1236, 29441808, 550);
|
||
|
|
moveCube[9] = new CubieCube1(9, 0, 5880, 0);
|
||
|
|
moveCube[12] = new CubieCube1(1230, 412, 2949660, 0);
|
||
|
|
moveCube[15] = new CubieCube1(224, 137, 328552, 137);
|
||
|
|
for (a = 0; a < 18; a += 3) {
|
||
|
|
for (p = 0; p < 2; ++p) {
|
||
|
|
moveCube[a + p + 1] = new CubieCube;
|
||
|
|
EdgeMult(moveCube[a + p], moveCube[a], moveCube[a + p + 1]);
|
||
|
|
CornMult(moveCube[a + p], moveCube[a], moveCube[a + p + 1]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function initPermSym2Raw() {
|
||
|
|
var a, b, c, count, d, i, idx, occ, s;
|
||
|
|
c = new CubieCube;
|
||
|
|
d = new CubieCube;
|
||
|
|
occ = createArray(1260);
|
||
|
|
count = 0;
|
||
|
|
for (i = 0; i < 1260; occ[i++] = 0) {}
|
||
|
|
epermR2S = createArray(40320);
|
||
|
|
for (i = 0; i < 40320; ++i) {
|
||
|
|
if ((occ[i >> 5] & 1 << (i & 31)) == 0) {
|
||
|
|
set8Perm(c.ep, i);
|
||
|
|
for (s = 0; s < 16; ++s) {
|
||
|
|
EdgeConjugate(c, s, d);
|
||
|
|
idx = get8Perm(d.ep);
|
||
|
|
idx == i && (SymStatePerm[count] |= 1 << s);
|
||
|
|
occ[idx >> 5] |= 1 << (idx & 31);
|
||
|
|
a = getComb(d.ep, 0);
|
||
|
|
b = getComb(d.ep, 4) >> 9;
|
||
|
|
MtoEPerm[494 - (a & 511)][(a >> 9) + b * 24] = epermR2S[idx] = count << 4 | s;
|
||
|
|
}
|
||
|
|
epermS2R[count++] = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function initSym() {
|
||
|
|
var c, d, f2, i, j, k, lr2, m, s, t, u4;
|
||
|
|
c = new CubieCube;
|
||
|
|
d = new CubieCube;
|
||
|
|
f2 = new CubieCube1(28783, 0, 259268407, 0);
|
||
|
|
u4 = new CubieCube1(15138, 0, 119765538, 7);
|
||
|
|
lr2 = new CubieCube1(5167, 0, 83473207, 0);
|
||
|
|
lr2.co = [3, 3, 3, 3, 3, 3, 3, 3];
|
||
|
|
for (i = 0; i < 16; ++i) {
|
||
|
|
CubeSym[i] = new CubieCube2(c);
|
||
|
|
CornMult(c, u4, d);
|
||
|
|
EdgeMult(c, u4, d);
|
||
|
|
t = d;
|
||
|
|
d = c;
|
||
|
|
c = t;
|
||
|
|
if (i % 4 == 3) {
|
||
|
|
CornMult(t, lr2, d);
|
||
|
|
EdgeMult(t, lr2, d);
|
||
|
|
t = d;
|
||
|
|
d = c;
|
||
|
|
c = t;
|
||
|
|
}
|
||
|
|
if (i % 8 == 7) {
|
||
|
|
CornMult(t, f2, d);
|
||
|
|
EdgeMult(t, f2, d);
|
||
|
|
t = d;
|
||
|
|
d = c;
|
||
|
|
c = t;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (i = 0; i < 16; ++i) {
|
||
|
|
for (j = 0; j < 16; ++j) {
|
||
|
|
CornMult(CubeSym[i], CubeSym[j], c);
|
||
|
|
for (k = 0; k < 16; ++k) {
|
||
|
|
if (CubeSym[k].cp[0] == c.cp[0] && CubeSym[k].cp[1] == c.cp[1] && CubeSym[k].cp[2] == c.cp[2]) {
|
||
|
|
SymMult[i][j] = k;
|
||
|
|
k == 0 && (SymInv[i] = j);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (j = 0; j < 18; ++j) {
|
||
|
|
for (s = 0; s < 16; ++s) {
|
||
|
|
cornConjugate(moveCube[j], SymInv[s], c);
|
||
|
|
CONTINUE: for (m = 0; m < 18; ++m) {
|
||
|
|
for (i = 0; i < 8; i += 2) {
|
||
|
|
if (c.cp[i] != moveCube[m].cp[i]) {
|
||
|
|
continue CONTINUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
SymMove[s][j] = m;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (j = 0; j < 10; ++j) {
|
||
|
|
for (s = 0; s < 16; ++s) {
|
||
|
|
SymMoveUD[s][j] = std2ud[SymMove[s][ud2std[j]]];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (j = 0; j < 8; ++j) {
|
||
|
|
for (s = 0; s < 8; ++s) {
|
||
|
|
Sym8Mult[j][s] = SymMult[j << 1][s << 1] >> 1;
|
||
|
|
Sym8MultInv[j][s] = SymMult[j << 1][SymInv[s << 1]] >> 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (j = 0; j < 18; ++j) {
|
||
|
|
for (s = 0; s < 8; ++s) {
|
||
|
|
Sym8Move[s][j] = SymMove[s << 1][j];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function initTwistSym2Raw() {
|
||
|
|
var c, count, d, i, idx, occ, s;
|
||
|
|
c = new CubieCube;
|
||
|
|
d = new CubieCube;
|
||
|
|
occ = createArray(69);
|
||
|
|
count = 0;
|
||
|
|
for (i = 0; i < 69; occ[i++] = 0) {}
|
||
|
|
TwistR2S = createArray(2187);
|
||
|
|
for (i = 0; i < 2187; ++i) {
|
||
|
|
if ((occ[i >> 5] & 1 << (i & 31)) == 0) {
|
||
|
|
$setTwist(c, i);
|
||
|
|
for (s = 0; s < 16; s += 2) {
|
||
|
|
cornConjugate(c, s, d);
|
||
|
|
idx = $getTwist(d);
|
||
|
|
idx == i && (SymStateTwist[count] = (SymStateTwist[count] | 1 << (s >> 1)));
|
||
|
|
occ[idx >> 5] |= 1 << (idx & 31);
|
||
|
|
TwistR2S[idx] = (count << 3 | s >> 1);
|
||
|
|
}
|
||
|
|
TwistS2R[count++] = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var _ = CubieCube2.prototype = CubieCube1.prototype = CubieCube.prototype;
|
||
|
|
_.temps = null;
|
||
|
|
var CubeSym, epermR2S = null,
|
||
|
|
epermS2R, FlipR2S = null,
|
||
|
|
FlipS2R, MtoEPerm, Sym8Move, Sym8Mult, Sym8MultInv, SymInv, SymMove, SymMoveUD, SymMult, SymStateFlip, SymStatePerm, SymStateTwist, TwistR2S = null,
|
||
|
|
TwistS2R, e2c, moveCube, urf1, urf2, urfMove;
|
||
|
|
|
||
|
|
function $initPhase2(obj) {
|
||
|
|
var cidx, csym, cx, d4e, depth2, edge, esym, i, lm, m, mid, prun, u4e;
|
||
|
|
if (+new Date > (obj.solution == null ? obj.timeOut : obj.timeMin)) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
obj.valid2 = Math.min(obj.valid2, obj.valid1);
|
||
|
|
cidx = obj.corn[obj.valid1] >>> 4;
|
||
|
|
csym = obj.corn[obj.valid1] & 15;
|
||
|
|
for (i = obj.valid1; i < obj.depth1; ++i) {
|
||
|
|
m = obj.move[i];
|
||
|
|
cidx = CPermMove[cidx][SymMove[csym][m]];
|
||
|
|
csym = SymMult[cidx & 15][csym];
|
||
|
|
cidx >>>= 4;
|
||
|
|
obj.corn[i + 1] = cidx << 4 | csym;
|
||
|
|
cx = UDSliceMove[obj.mid4[i] & 511][m];
|
||
|
|
obj.mid4[i + 1] = permMult[obj.mid4[i] >>> 9][cx >>> 9] << 9 | cx & 511;
|
||
|
|
}
|
||
|
|
obj.valid1 = obj.depth1;
|
||
|
|
mid = obj.mid4[obj.depth1] >>> 9;
|
||
|
|
prun = getPruning(MCPermPrun, cidx * 24 + MPermConj[mid][csym]);
|
||
|
|
if (prun >= obj.maxDep2) {
|
||
|
|
return prun > obj.maxDep2 ? 2 : 1;
|
||
|
|
}
|
||
|
|
u4e = obj.ud8e[obj.valid2] >>> 16;
|
||
|
|
d4e = obj.ud8e[obj.valid2] & 65535;
|
||
|
|
for (i = obj.valid2; i < obj.depth1; ++i) {
|
||
|
|
m = obj.move[i];
|
||
|
|
cx = UDSliceMove[u4e & 511][m];
|
||
|
|
u4e = permMult[u4e >>> 9][cx >>> 9] << 9 | cx & 511;
|
||
|
|
cx = UDSliceMove[d4e & 511][m];
|
||
|
|
d4e = permMult[d4e >>> 9][cx >>> 9] << 9 | cx & 511;
|
||
|
|
obj.ud8e[i + 1] = u4e << 16 | d4e;
|
||
|
|
}
|
||
|
|
obj.valid2 = obj.depth1;
|
||
|
|
edge = MtoEPerm[494 - (u4e & 511)][(u4e >>> 9) + (d4e >>> 9) * 24];
|
||
|
|
esym = edge & 15;
|
||
|
|
edge >>>= 4;
|
||
|
|
prun = Math.max(getPruning(MEPermPrun, edge * 24 + MPermConj[mid][esym]), prun);
|
||
|
|
if (prun >= obj.maxDep2) {
|
||
|
|
return prun > obj.maxDep2 ? 2 : 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
lm = 10;
|
||
|
|
if (obj.depth1 > 2 && ~~(obj.move[obj.depth1 - 1] / 3) % 3 == ~~(obj.move[obj.depth1 - 2] / 3) % 3) {
|
||
|
|
lm = std2ud[~~(Math.max(obj.move[obj.depth1 - 1], obj.move[obj.depth1 - 2]) / 3) * 3 + 1];
|
||
|
|
} else if (obj.depth1 > 1) {
|
||
|
|
lm = std2ud[~~(obj.move[obj.depth1 - 1] / 3) * 3 + 1];
|
||
|
|
if (obj.move[obj.depth1 - 1] > 8) {
|
||
|
|
lm = -lm;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (depth2 = obj.maxDep2 - 1; depth2 >= prun; --depth2) {
|
||
|
|
var ret = $phase2(obj, edge, esym, cidx, csym, mid, depth2, obj.depth1, lm);
|
||
|
|
if (ret < 0) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
depth2 = depth2 - ret;
|
||
|
|
obj.sol = obj.depth1 + depth2;
|
||
|
|
if (obj.preIdx != 0) {
|
||
|
|
var preMove = [-1, 3, 5, 6, 8, 12, 14, 15, 17];
|
||
|
|
var axisPre = ~~(preMove[obj.preIdx] / 3);
|
||
|
|
var axisLast = ~~(obj.move[obj.sol - 1] / 3);
|
||
|
|
if (axisPre == axisLast) {
|
||
|
|
var pow = (preMove[obj.preIdx] % 3 + obj.move[obj.sol - 1] % 3 + 1) % 4;
|
||
|
|
obj.move[obj.sol - 1] = axisPre * 3 + pow;
|
||
|
|
} else if (depth2 > 1 && axisPre % 3 == axisLast % 3 && ~~(obj.move[obj.sol - 2] / 3) == axisPre) {
|
||
|
|
var pow = (preMove[obj.preIdx] % 3 + obj.move[obj.sol - 2] % 3 + 1) % 4;
|
||
|
|
obj.move[obj.sol - 2] = axisPre * 3 + pow;
|
||
|
|
} else {
|
||
|
|
obj.move[obj.sol++] = preMove[obj.preIdx];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
obj.solution = $solutionToString(obj);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (depth2 != obj.maxDep2 - 1) { //At least one solution has been found.
|
||
|
|
obj.maxDep2 = Math.min(12, obj.sol - obj.depth1);
|
||
|
|
return (+new Date > obj.timeMin) ? 0 : 1;
|
||
|
|
} else {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function $phase1(obj, twist, tsym, flip, fsym, slice, maxl, lm) {
|
||
|
|
var axis, flipx, fsymx, m, power, prun, ret, slicex, tsymx, twistx;
|
||
|
|
if (twist == 0 && flip == 0 && slice == 0 && maxl < 5) {
|
||
|
|
return maxl == 0 ? $initPhase2(obj) : 1;
|
||
|
|
}
|
||
|
|
for (axis = 0; axis < 18; axis += 3) {
|
||
|
|
if (axis == lm || axis == lm - 9) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
for (power = 0; power < 3; ++power) {
|
||
|
|
m = axis + power;
|
||
|
|
slicex = UDSliceMove[slice][m] & 511;
|
||
|
|
twistx = TwistMove[twist][Sym8Move[tsym][m]];
|
||
|
|
tsymx = Sym8Mult[twistx & 7][tsym];
|
||
|
|
twistx >>>= 3;
|
||
|
|
prun = getPruning(UDSliceTwistPrun, twistx * 495 + UDSliceConj[slicex][tsymx]);
|
||
|
|
if (prun > maxl) {
|
||
|
|
break;
|
||
|
|
} else if (prun == maxl) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
flipx = FlipMove[flip][Sym8Move[fsym][m]];
|
||
|
|
fsymx = Sym8Mult[flipx & 7][fsym];
|
||
|
|
flipx >>>= 3;
|
||
|
|
prun = getPruning(UDSliceFlipPrun, flipx * 495 + UDSliceConj[slicex][fsymx]);
|
||
|
|
if (prun > maxl) {
|
||
|
|
break;
|
||
|
|
} else if (prun == maxl) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
obj.move[obj.depth1 - maxl] = m;
|
||
|
|
obj.valid1 = Math.min(obj.valid1, obj.depth1 - maxl);
|
||
|
|
ret = $phase1(obj, twistx, tsymx, flipx, fsymx, slicex, maxl - 1, axis);
|
||
|
|
if (ret != 1) {
|
||
|
|
return ret >> 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
function $phase2(obj, eidx, esym, cidx, csym, mid, maxl, depth, lm) {
|
||
|
|
var cidxx, csymx, eidxx, esymx, m, midx;
|
||
|
|
if (eidx == 0 && cidx == 0 && mid == 0) {
|
||
|
|
return maxl;
|
||
|
|
}
|
||
|
|
for (m = 0; m < 10; ++m) {
|
||
|
|
if (lm < 0 ? (m == -lm) : ckmv2[lm][m]) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
midx = MPermMove[mid][m];
|
||
|
|
cidxx = CPermMove[cidx][SymMove[csym][ud2std[m]]];
|
||
|
|
csymx = SymMult[cidxx & 15][csym];
|
||
|
|
cidxx >>>= 4;
|
||
|
|
if (getPruning(MCPermPrun, cidxx * 24 + MPermConj[midx][csymx]) >= maxl) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
eidxx = EPermMove[eidx][SymMoveUD[esym][m]];
|
||
|
|
esymx = SymMult[eidxx & 15][esym];
|
||
|
|
eidxx >>>= 4;
|
||
|
|
if (getPruning(MEPermPrun, eidxx * 24 + MPermConj[midx][esymx]) >= maxl) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
var ret = $phase2(obj, eidxx, esymx, cidxx, csymx, midx, maxl - 1, depth + 1, (lm < 0 && m + lm == -5) ? -lm : m);
|
||
|
|
if (ret >= 0) {
|
||
|
|
obj.move[depth] = ud2std[m];
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
function $solution(obj, facelets, maxDepth, timeOut, timeMin, verbose) {
|
||
|
|
Search_$verify(obj, facelets);
|
||
|
|
obj.sol = (maxDepth || 21) + 1;
|
||
|
|
obj.timeOut = +new Date + (timeOut || 10000);
|
||
|
|
obj.timeMin = obj.timeOut + Math.min((timeMin || 50) - (timeOut || 10000), 0);
|
||
|
|
obj.verbose = verbose || 2;
|
||
|
|
obj.solution = null;
|
||
|
|
return $solve(obj, obj.cc);
|
||
|
|
}
|
||
|
|
|
||
|
|
function $solutionToString(obj) {
|
||
|
|
var s, sb, urf;
|
||
|
|
sb = '';
|
||
|
|
urf = (obj.verbose & 2) != 0 ? (obj.urfIdx + 3) % 6 : obj.urfIdx;
|
||
|
|
if (urf < 3) {
|
||
|
|
for (s = 0; s < obj.sol; ++s) {
|
||
|
|
sb += move2str[urfMove[urf][obj.move[s]]] + ' ';
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (s = obj.sol - 1; s >= 0; --s) {
|
||
|
|
sb += move2str[urfMove[urf][obj.move[s]]] + ' ';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return sb;
|
||
|
|
}
|
||
|
|
|
||
|
|
function $solve(obj, c) {
|
||
|
|
var conjMask, i, j;
|
||
|
|
conjMask = 0;
|
||
|
|
|
||
|
|
var pc = new CubieCube;
|
||
|
|
var preList = [
|
||
|
|
new CubieCube, moveCube[3], moveCube[5],
|
||
|
|
moveCube[6], moveCube[8], moveCube[12],
|
||
|
|
moveCube[14], moveCube[15], moveCube[17]
|
||
|
|
];
|
||
|
|
|
||
|
|
for (i = 0; i < 6; ++i) {
|
||
|
|
|
||
|
|
for (j = 0; j < 9; j++) {
|
||
|
|
CornMult(preList[j], c, pc);
|
||
|
|
EdgeMult(preList[j], c, pc);
|
||
|
|
obj.twist[i][j] = $getTwistSym(pc);
|
||
|
|
obj.flip[i][j] = $getFlipSym(pc);
|
||
|
|
obj.slice[i][j] = getComb(pc.ep, 8);
|
||
|
|
obj.corn0[i][j] = $getCPermSym(pc);
|
||
|
|
obj.ud8e0[i][j] = getComb(pc.ep, 0) << 16 | getComb(pc.ep, 4);
|
||
|
|
}
|
||
|
|
|
||
|
|
!c.temps && (c.temps = new CubieCube);
|
||
|
|
CornMult(urf2, c, c.temps);
|
||
|
|
CornMult(c.temps, urf1, c);
|
||
|
|
EdgeMult(urf2, c, c.temps);
|
||
|
|
EdgeMult(c.temps, urf1, c);
|
||
|
|
(i % 3 == 2) && $invCubieCube(c);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i = 0; i < 6; i++) {
|
||
|
|
for (j = 0; j < i; j++) { //If S_i^-1 * C * S_i == C, It's unnecessary to compute it again.
|
||
|
|
if (obj.twist[i][0] == obj.twist[j][0] && obj.flip[i][0] == obj.flip[j][0] && obj.slice[i][0] == obj.slice[j][0] && obj.corn0[i][0] == obj.corn0[j][0] && obj.ud8e0[i][0] == obj.ud8e0[j][0]) {
|
||
|
|
conjMask |= 1 << i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ((conjMask & (1 << i)) != 0) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
for (j = 0; j < 9; j++) {
|
||
|
|
obj.prun[i][j] = Math.max(
|
||
|
|
getPruning(UDSliceTwistPrun, (obj.twist[i][j] >>> 3) * 495 + UDSliceConj[obj.slice[i][j] & 0x1ff][obj.twist[i][j] & 7]),
|
||
|
|
getPruning(UDSliceFlipPrun, (obj.flip[i][j] >>> 3) * 495 + UDSliceConj[obj.slice[i][j] & 0x1ff][obj.flip[i][j] & 7]));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (obj.depth1 = 0; obj.depth1 < obj.sol; ++obj.depth1) {
|
||
|
|
obj.maxDep2 = Math.min(12, obj.sol - obj.depth1);
|
||
|
|
for (obj.urfIdx = 0; obj.urfIdx < 6; ++obj.urfIdx) {
|
||
|
|
if ((conjMask & 1 << obj.urfIdx) != 0) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (obj.preIdx = 0; obj.preIdx < 9; obj.preIdx++) {
|
||
|
|
obj.corn[0] = obj.corn0[obj.urfIdx][obj.preIdx];
|
||
|
|
obj.mid4[0] = obj.slice[obj.urfIdx][obj.preIdx];
|
||
|
|
obj.ud8e[0] = obj.ud8e0[obj.urfIdx][obj.preIdx];
|
||
|
|
obj.valid1 = obj.valid2 = 0;
|
||
|
|
if (obj.preIdx != 0) {
|
||
|
|
obj.depth1--;
|
||
|
|
}
|
||
|
|
if ((obj.prun[obj.urfIdx][obj.preIdx] <= obj.depth1) && $phase1(obj, obj.twist[obj.urfIdx][obj.preIdx] >>> 3, obj.twist[obj.urfIdx][obj.preIdx] & 7,
|
||
|
|
obj.flip[obj.urfIdx][obj.preIdx] >>> 3, obj.flip[obj.urfIdx][obj.preIdx] & 7,
|
||
|
|
obj.slice[obj.urfIdx][obj.preIdx] & 0x1ff, obj.depth1, -1) == 0) {
|
||
|
|
return obj.solution == null ? "Error 8" : obj.solution;
|
||
|
|
}
|
||
|
|
if (obj.preIdx != 0) {
|
||
|
|
obj.depth1++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return obj.solution == null ? 'Error 7' : obj.solution;
|
||
|
|
}
|
||
|
|
|
||
|
|
function Search_$verify(obj, facelets) {
|
||
|
|
var count = 0, i;
|
||
|
|
for (i = 0; i < 54; ++i) {
|
||
|
|
switch (facelets.charCodeAt(i)) {
|
||
|
|
case 85:
|
||
|
|
obj.f[i] = 0;
|
||
|
|
break;
|
||
|
|
case 82:
|
||
|
|
obj.f[i] = 1;
|
||
|
|
break;
|
||
|
|
case 70:
|
||
|
|
obj.f[i] = 2;
|
||
|
|
break;
|
||
|
|
case 68:
|
||
|
|
obj.f[i] = 3;
|
||
|
|
break;
|
||
|
|
case 76:
|
||
|
|
obj.f[i] = 4;
|
||
|
|
break;
|
||
|
|
case 66:
|
||
|
|
obj.f[i] = 5;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
count += 1 << (obj.f[i] << 2);
|
||
|
|
}
|
||
|
|
if (count != 10066329) {
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
toCubieCube(obj.f, obj.cc);
|
||
|
|
}
|
||
|
|
|
||
|
|
function Search() {
|
||
|
|
this.move = [];
|
||
|
|
this.corn = [];
|
||
|
|
this.mid4 = [];
|
||
|
|
this.ud8e = [];
|
||
|
|
this.twist = createArray(6, 9);
|
||
|
|
this.flip = createArray(6, 9);
|
||
|
|
this.slice = createArray(6, 9);
|
||
|
|
this.corn0 = createArray(6, 9);
|
||
|
|
this.ud8e0 = createArray(6, 9);
|
||
|
|
this.prun = createArray(6, 9);
|
||
|
|
this.f = createArray(6, 9);
|
||
|
|
this.cc = new CubieCube;
|
||
|
|
}
|
||
|
|
|
||
|
|
_ = Search.prototype;
|
||
|
|
_.depth1 = 0;
|
||
|
|
_.maxDep2 = 0;
|
||
|
|
_.sol = 0;
|
||
|
|
_.solution = null;
|
||
|
|
_.timeMin = 0;
|
||
|
|
_.timeOut = 0;
|
||
|
|
_.urfIdx = 0;
|
||
|
|
_.preIdx = 0;
|
||
|
|
_.valid1 = 0;
|
||
|
|
_.valid2 = 0;
|
||
|
|
_.verbose = 0;
|
||
|
|
|
||
|
|
function Util_$clinit() {
|
||
|
|
var arr1, arr2, arr3, i, ix, j, jx, k;
|
||
|
|
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]
|
||
|
|
];
|
||
|
|
edgeFacelet = [
|
||
|
|
[5, 10],
|
||
|
|
[7, 19],
|
||
|
|
[3, 37],
|
||
|
|
[1, 46],
|
||
|
|
[32, 16],
|
||
|
|
[28, 25],
|
||
|
|
[30, 43],
|
||
|
|
[34, 52],
|
||
|
|
[23, 12],
|
||
|
|
[21, 41],
|
||
|
|
[50, 39],
|
||
|
|
[48, 14]
|
||
|
|
];
|
||
|
|
permMult = createArray(24, 24);
|
||
|
|
move2str = ['U ', 'U2', "U'", 'R ', 'R2', "R'", 'F ', 'F2', "F'", 'D ', 'D2', "D'", 'L ', 'L2', "L'", 'B ', 'B2', "B'"];
|
||
|
|
ud2std = [0, 1, 2, 4, 7, 9, 10, 11, 13, 16];
|
||
|
|
std2ud = createArray(18);
|
||
|
|
ckmv2 = createArray(11, 10);
|
||
|
|
for (i = 0; i < 10; ++i) {
|
||
|
|
std2ud[ud2std[i]] = i;
|
||
|
|
}
|
||
|
|
for (i = 0; i < 10; ++i) {
|
||
|
|
for (j = 0; j < 10; ++j) {
|
||
|
|
ix = ud2std[i];
|
||
|
|
jx = ud2std[j];
|
||
|
|
ckmv2[i][j] = ~~(ix / 3) == ~~(jx / 3) || ~~(ix / 3) % 3 == ~~(jx / 3) % 3 && ix >= jx;
|
||
|
|
}
|
||
|
|
ckmv2[10][i] = false;
|
||
|
|
}
|
||
|
|
arr1 = createArray(4);
|
||
|
|
arr2 = createArray(4);
|
||
|
|
arr3 = createArray(4);
|
||
|
|
for (i = 0; i < 24; ++i) {
|
||
|
|
for (j = 0; j < 24; ++j) {
|
||
|
|
setNPerm(arr1, i, 4);
|
||
|
|
setNPerm(arr2, j, 4);
|
||
|
|
for (k = 0; k < 4; ++k) {
|
||
|
|
arr3[k] = arr1[arr2[k]];
|
||
|
|
}
|
||
|
|
permMult[i][j] = getNPerm(arr3, 4);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function binarySearch(arr, key) {
|
||
|
|
var l, length, mid, r, val;
|
||
|
|
length = arr.length;
|
||
|
|
if (key <= arr[length - 1]) {
|
||
|
|
l = 0;
|
||
|
|
r = length - 1;
|
||
|
|
while (l <= r) {
|
||
|
|
mid = (l + r) >>> 1;
|
||
|
|
val = arr[mid];
|
||
|
|
if (key > val) {
|
||
|
|
l = mid + 1;
|
||
|
|
} else if (key < val) {
|
||
|
|
r = mid - 1;
|
||
|
|
} else {
|
||
|
|
return mid;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 65535;
|
||
|
|
}
|
||
|
|
|
||
|
|
function getComb(arr, mask) {
|
||
|
|
var i, idxC, idxP, r, v, val;
|
||
|
|
idxC = 0;
|
||
|
|
idxP = 0;
|
||
|
|
r = 4;
|
||
|
|
val = 291;
|
||
|
|
for (i = 11; i >= 0; --i) {
|
||
|
|
if ((arr[i] & 12) == mask) {
|
||
|
|
v = (arr[i] & 3) << 2;
|
||
|
|
idxP = r * idxP + (val >> v & 15);
|
||
|
|
val -= 273 >> 12 - v;
|
||
|
|
idxC += Cnk[i][r--];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return idxP << 9 | 494 - idxC;
|
||
|
|
}
|
||
|
|
|
||
|
|
function setComb(arr, idx) {
|
||
|
|
var fill, i, idxC, idxP, m, p, r, v, val;
|
||
|
|
r = 4;
|
||
|
|
fill = 11;
|
||
|
|
val = 291;
|
||
|
|
idxC = 494 - (idx & 511);
|
||
|
|
idxP = idx >>> 9;
|
||
|
|
for (i = 11; i >= 0; --i) {
|
||
|
|
if (idxC >= Cnk[i][r]) {
|
||
|
|
idxC -= Cnk[i][r--];
|
||
|
|
p = fact[r & 3];
|
||
|
|
v = ~~(idxP / p) << 2;
|
||
|
|
idxP %= p;
|
||
|
|
arr[i] = val >> v & 3 | 8;
|
||
|
|
m = (1 << v) - 1;
|
||
|
|
val = (val & m) + (val >> 4 & ~m);
|
||
|
|
} else {
|
||
|
|
(fill & 12) == 8 && (fill -= 4);
|
||
|
|
arr[i] = fill--;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function toCubieCube(f, ccRet) {
|
||
|
|
var col1, col2, i, j, ori;
|
||
|
|
for (i = 0; i < 8; ++i)
|
||
|
|
ccRet.cp[i] = 0;
|
||
|
|
for (i = 0; i < 12; ++i)
|
||
|
|
ccRet.ep[i] = 0;
|
||
|
|
for (i = 0; i < 8; ++i) {
|
||
|
|
for (ori = 0; ori < 3; ++ori)
|
||
|
|
if (f[cornerFacelet[i][ori]] == 0 || f[cornerFacelet[i][ori]] == 3)
|
||
|
|
break;
|
||
|
|
col1 = f[cornerFacelet[i][(ori + 1) % 3]];
|
||
|
|
col2 = f[cornerFacelet[i][(ori + 2) % 3]];
|
||
|
|
for (j = 0; j < 8; ++j) {
|
||
|
|
if (col1 == ~~(cornerFacelet[j][1] / 9) && col2 == ~~(cornerFacelet[j][2] / 9)) {
|
||
|
|
ccRet.cp[i] = j;
|
||
|
|
ccRet.co[i] = ori % 3;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (i = 0; i < 12; ++i) {
|
||
|
|
for (j = 0; j < 12; ++j) {
|
||
|
|
if (f[edgeFacelet[i][0]] == ~~(edgeFacelet[j][0] / 9) && f[edgeFacelet[i][1]] == ~~(edgeFacelet[j][1] / 9)) {
|
||
|
|
ccRet.ep[i] = j;
|
||
|
|
ccRet.eo[i] = 0;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (f[edgeFacelet[i][0]] == ~~(edgeFacelet[j][1] / 9) && f[edgeFacelet[i][1]] == ~~(edgeFacelet[j][0] / 9)) {
|
||
|
|
ccRet.ep[i] = j;
|
||
|
|
ccRet.eo[i] = 1;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function toFaceCube(cc) {
|
||
|
|
var c, e, f, i, j, n, ori, ts;
|
||
|
|
f = createArray(54);
|
||
|
|
ts = [85, 82, 70, 68, 76, 66];
|
||
|
|
for (i = 0; i < 54; ++i) {
|
||
|
|
f[i] = ts[~~(i / 9)];
|
||
|
|
}
|
||
|
|
for (c = 0; c < 8; ++c) {
|
||
|
|
j = cc.cp[c];
|
||
|
|
ori = cc.co[c];
|
||
|
|
for (n = 0; n < 3; ++n)
|
||
|
|
f[cornerFacelet[c][(n + ori) % 3]] = ts[~~(cornerFacelet[j][n] / 9)];
|
||
|
|
}
|
||
|
|
for (e = 0; e < 12; ++e) {
|
||
|
|
j = cc.ep[e];
|
||
|
|
ori = cc.eo[e];
|
||
|
|
for (n = 0; n < 2; ++n)
|
||
|
|
f[edgeFacelet[e][(n + ori) % 2]] = ts[~~(edgeFacelet[j][n] / 9)];
|
||
|
|
}
|
||
|
|
return String.fromCharCode.apply(null, f);
|
||
|
|
}
|
||
|
|
|
||
|
|
var ckmv2, cornerFacelet, edgeFacelet, move2str, permMult, std2ud, ud2std;
|
||
|
|
|
||
|
|
function initialize() {
|
||
|
|
// var startTime = +new Date;
|
||
|
|
Util_$clinit();
|
||
|
|
CubieCube_$clinit();
|
||
|
|
CoordCube_$clinit();
|
||
|
|
initMove();
|
||
|
|
initSym();
|
||
|
|
initFlipSym2Raw();
|
||
|
|
initTwistSym2Raw();
|
||
|
|
initPermSym2Raw();
|
||
|
|
initMoveTable(FlipMove, 336, FlipS2R, $setFlip, $getFlipSym, true, false);
|
||
|
|
initMoveTable(TwistMove, 324, TwistS2R, $setTwist, $getTwistSym, false, false);
|
||
|
|
initUDSliceMoveConj();
|
||
|
|
initMoveTable(CPermMove, 2768, epermS2R, $setCPerm, $getCPermSym, false, false);
|
||
|
|
initMoveTable(EPermMove, 2768, epermS2R, $setEPerm, $getEPermSym, true, true);
|
||
|
|
initMPermMoveConj();
|
||
|
|
epermR2S = null;
|
||
|
|
// console.log(+new Date - startTime);
|
||
|
|
initRawSymPrun(UDSliceTwistPrun, 6, UDSliceMove, UDSliceConj, TwistMove, SymStateTwist, null, null, 3);
|
||
|
|
initRawSymPrun(UDSliceFlipPrun, 6, UDSliceMove, UDSliceConj, FlipMove, SymStateFlip, null, null, 3);
|
||
|
|
initRawSymPrun(MEPermPrun, 7, MPermMove, MPermConj, EPermMove, SymStatePerm, null, null, 4);
|
||
|
|
initRawSymPrun(MCPermPrun, 10, MPermMove, MPermConj, CPermMove, SymStatePerm, e2c, ud2std, 4);
|
||
|
|
// console.log(+new Date - startTime);
|
||
|
|
}
|
||
|
|
|
||
|
|
var initialized = false;
|
||
|
|
|
||
|
|
function ini() {
|
||
|
|
if (!initialized) {
|
||
|
|
initialize();
|
||
|
|
search = new Search;
|
||
|
|
initialized = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// SCRAMBLERS
|
||
|
|
|
||
|
|
var search;
|
||
|
|
|
||
|
|
function getRandomOriScramble() {
|
||
|
|
return getAnyScramble(0xfff, 0xfff, 0xff, 0xff) + rndEl(["", "Rw ", "Rw2 ", "Rw' ", "Fw ", "Fw' "]) + rndEl(["", "Uw", "Uw2", "Uw'"]);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getRandomScramble() {
|
||
|
|
return getAnyScramble(0xfff, 0xfff, 0xff, 0xff);
|
||
|
|
}
|
||
|
|
|
||
|
|
function cntU(b) {
|
||
|
|
for (var c = 0, a = 0; a < b.length; a++) - 1 == b[a] && c++;
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function fixOri(arr, cntU, base) {
|
||
|
|
var sum = 0;
|
||
|
|
var idx = 0;
|
||
|
|
for (var i = 0; i < arr.length; i++) {
|
||
|
|
if (arr[i] != -1) {
|
||
|
|
sum += arr[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
sum %= base;
|
||
|
|
for (var i = 0; i < arr.length - 1; i++) {
|
||
|
|
if (arr[i] == -1) {
|
||
|
|
if (cntU-- == 1) {
|
||
|
|
arr[i] = ((base << 4) - sum) % base;
|
||
|
|
} else {
|
||
|
|
arr[i] = rn(base);
|
||
|
|
sum += arr[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
idx *= base;
|
||
|
|
idx += arr[i];
|
||
|
|
}
|
||
|
|
return idx;
|
||
|
|
}
|
||
|
|
|
||
|
|
function fixPerm(arr, cntU, parity) {
|
||
|
|
var val = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
|
||
|
|
for (var i = 0; i < arr.length; i++) {
|
||
|
|
if (arr[i] != -1) {
|
||
|
|
val[arr[i]] = -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (var i = 0, j = 0; i < val.length; i++) {
|
||
|
|
if (val[i] != -1) {
|
||
|
|
val[j++] = val[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var last;
|
||
|
|
for (var i = 0; i < arr.length && cntU > 0; i++) {
|
||
|
|
if (arr[i] == -1) {
|
||
|
|
var r = rn(cntU);
|
||
|
|
arr[i] = val[r];
|
||
|
|
for (var j = r; j < 11; j++) {
|
||
|
|
val[j] = val[j + 1];
|
||
|
|
}
|
||
|
|
if (cntU-- == 2) {
|
||
|
|
last = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (getNParity(getNPerm(arr, arr.length), arr.length) == 1 - parity) {
|
||
|
|
var temp = arr[i - 1];
|
||
|
|
arr[i - 1] = arr[last];
|
||
|
|
arr[last] = temp;
|
||
|
|
}
|
||
|
|
return getNPerm(arr, arr.length);
|
||
|
|
}
|
||
|
|
|
||
|
|
function isNumeric(n) {
|
||
|
|
return !isNaN(parseFloat(n)) && isFinite(n);
|
||
|
|
}
|
||
|
|
|
||
|
|
function parseMask(arr, length, ori) {
|
||
|
|
if (isNumeric(arr)) {
|
||
|
|
var ret = [];
|
||
|
|
for (var i = 0; i < length; i++) {
|
||
|
|
ret[i] = (arr & 1) ? -1 : (ori ? 0 : i);
|
||
|
|
arr >>= 1;
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
} else {
|
||
|
|
return arr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function getAnyScramble(_ep, _eo, _cp, _co, _rndapp, _rndpre) {
|
||
|
|
ini();
|
||
|
|
_rndapp = _rndapp || [[]];
|
||
|
|
_rndpre = _rndpre || [[]];
|
||
|
|
_ep = parseMask(_ep, 12, false);
|
||
|
|
_eo = parseMask(_eo, 12, true);
|
||
|
|
_cp = parseMask(_cp, 8, false);
|
||
|
|
_co = parseMask(_co, 8, true);
|
||
|
|
var solution = "";
|
||
|
|
do {
|
||
|
|
var eo = _eo.slice();
|
||
|
|
var ep = _ep.slice();
|
||
|
|
var co = _co.slice();
|
||
|
|
var cp = _cp.slice();
|
||
|
|
var neo = fixOri(eo, cntU(eo), 2);
|
||
|
|
var nco = fixOri(co, cntU(co), 3);
|
||
|
|
var nep, ncp;
|
||
|
|
var ue = cntU(ep);
|
||
|
|
var uc = cntU(cp);
|
||
|
|
if (ue == 0 && uc == 0) {
|
||
|
|
nep = getNPerm(ep, 12);
|
||
|
|
ncp = getNPerm(cp, 8);
|
||
|
|
} else if (ue != 0 && uc == 0) {
|
||
|
|
ncp = getNPerm(cp, 8);
|
||
|
|
nep = fixPerm(ep, ue, getNParity(ncp, 8));
|
||
|
|
} else if (ue == 0 && uc != 0) {
|
||
|
|
nep = getNPerm(ep, 12);
|
||
|
|
ncp = fixPerm(cp, uc, getNParity(nep, 12));
|
||
|
|
} else {
|
||
|
|
nep = fixPerm(ep, ue, -1);
|
||
|
|
ncp = fixPerm(cp, uc, getNParity(nep, 12));
|
||
|
|
}
|
||
|
|
if (ncp + nco + nep + neo == 0) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
var cc = new CubieCube1(ncp, nco, nep, neo);
|
||
|
|
var cc2 = new CubieCube;
|
||
|
|
var rndpre = rndEl(_rndpre);
|
||
|
|
var rndapp = rndEl(_rndapp);
|
||
|
|
for (var i = 0; i < rndapp.length; i++) {
|
||
|
|
CornMult(moveCube[rndapp[i]], cc, cc2);
|
||
|
|
EdgeMult(moveCube[rndapp[i]], cc, cc2);
|
||
|
|
var tmp = cc2;
|
||
|
|
cc2 = cc;
|
||
|
|
cc = tmp;
|
||
|
|
}
|
||
|
|
for (var i = 0; i < rndapp.length; i++) {
|
||
|
|
CornMult(cc, moveCube[rndapp[i]], cc2);
|
||
|
|
EdgeMult(cc, moveCube[rndapp[i]], cc2);
|
||
|
|
var tmp = cc2;
|
||
|
|
cc2 = cc;
|
||
|
|
cc = tmp;
|
||
|
|
}
|
||
|
|
var posit = toFaceCube(cc);
|
||
|
|
solution = $solution(search, posit);
|
||
|
|
} while (solution.length <= 3);
|
||
|
|
return solution.replace(/ +/g, ' ');
|
||
|
|
}
|
||
|
|
|
||
|
|
function getEdgeScramble() {
|
||
|
|
return getAnyScramble(0xfff, 0xfff, 0, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getCornerScramble() {
|
||
|
|
return getAnyScramble(0, 0, 0xff, 0xff);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getLLScramble() {
|
||
|
|
return getAnyScramble(0xf, 0xf, 0xf, 0xf);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getLSLLScramble() {
|
||
|
|
return getAnyScramble(0x10f, 0x10f, 0x1f, 0x1f);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getF2LScramble() {
|
||
|
|
return getAnyScramble(0xf0f, 0xf0f, 0xff, 0xff);
|
||
|
|
}
|
||
|
|
|
||
|
|
var zbll_map = [
|
||
|
|
[[0, 1, 2, 3, 4, 5, 6, 7], [1, 2, 1, 2, 0, 0, 0, 0]], // H-BBFF
|
||
|
|
[[2, 1, 0, 3, 4, 5, 6, 7], [1, 2, 1, 2, 0, 0, 0, 0]], // H-FBFB
|
||
|
|
[[0, 2, 1, 3, 4, 5, 6, 7], [1, 2, 1, 2, 0, 0, 0, 0]], // H-RFLF
|
||
|
|
[[1, 0, 2, 3, 4, 5, 6, 7], [1, 2, 1, 2, 0, 0, 0, 0]], // H-RLFF
|
||
|
|
[[2, 1, 0, 3, 4, 5, 6, 7], [0, 2, 0, 1, 0, 0, 0, 0]], // L-FBRL
|
||
|
|
[[1, 2, 0, 3, 4, 5, 6, 7], [0, 2, 0, 1, 0, 0, 0, 0]], // L-LBFF
|
||
|
|
[[1, 0, 2, 3, 4, 5, 6, 7], [0, 2, 0, 1, 0, 0, 0, 0]], // L-LFFB
|
||
|
|
[[2, 0, 1, 3, 4, 5, 6, 7], [0, 2, 0, 1, 0, 0, 0, 0]], // L-LFFR
|
||
|
|
[[0, 1, 2, 3, 4, 5, 6, 7], [0, 2, 0, 1, 0, 0, 0, 0]], // L-LRFF
|
||
|
|
[[0, 2, 1, 3, 4, 5, 6, 7], [0, 2, 0, 1, 0, 0, 0, 0]], // L-RFBL
|
||
|
|
[[2, 0, 1, 3, 4, 5, 6, 7], [2, 2, 1, 1, 0, 0, 0, 0]], // Pi-BFFB
|
||
|
|
[[0, 2, 1, 3, 4, 5, 6, 7], [2, 2, 1, 1, 0, 0, 0, 0]], // Pi-FBFB
|
||
|
|
[[2, 1, 0, 3, 4, 5, 6, 7], [2, 2, 1, 1, 0, 0, 0, 0]], // Pi-FRFL
|
||
|
|
[[1, 2, 0, 3, 4, 5, 6, 7], [2, 2, 1, 1, 0, 0, 0, 0]], // Pi-FRLF
|
||
|
|
[[0, 1, 2, 3, 4, 5, 6, 7], [2, 2, 1, 1, 0, 0, 0, 0]], // Pi-LFRF
|
||
|
|
[[1, 0, 2, 3, 4, 5, 6, 7], [2, 2, 1, 1, 0, 0, 0, 0]], // Pi-RFFL
|
||
|
|
[[0, 2, 1, 3, 4, 5, 6, 7], [0, 2, 2, 2, 0, 0, 0, 0]], // S-FBBF
|
||
|
|
[[2, 0, 1, 3, 4, 5, 6, 7], [0, 2, 2, 2, 0, 0, 0, 0]], // S-FBFB
|
||
|
|
[[0, 1, 2, 3, 4, 5, 6, 7], [0, 2, 2, 2, 0, 0, 0, 0]], // S-FLFR
|
||
|
|
[[1, 0, 2, 3, 4, 5, 6, 7], [0, 2, 2, 2, 0, 0, 0, 0]], // S-FLRF
|
||
|
|
[[1, 2, 0, 3, 4, 5, 6, 7], [0, 2, 2, 2, 0, 0, 0, 0]], // S-LFFR
|
||
|
|
[[2, 1, 0, 3, 4, 5, 6, 7], [0, 2, 2, 2, 0, 0, 0, 0]], // S-LFRF
|
||
|
|
[[0, 1, 2, 3, 4, 5, 6, 7], [0, 0, 1, 2, 0, 0, 0, 0]], // T-BBFF
|
||
|
|
[[2, 1, 0, 3, 4, 5, 6, 7], [0, 0, 1, 2, 0, 0, 0, 0]], // T-FBFB
|
||
|
|
[[1, 0, 2, 3, 4, 5, 6, 7], [0, 0, 1, 2, 0, 0, 0, 0]], // T-FFLR
|
||
|
|
[[0, 2, 1, 3, 4, 5, 6, 7], [0, 0, 1, 2, 0, 0, 0, 0]], // T-FLFR
|
||
|
|
[[2, 0, 1, 3, 4, 5, 6, 7], [0, 0, 1, 2, 0, 0, 0, 0]], // T-RFLF
|
||
|
|
[[1, 2, 0, 3, 4, 5, 6, 7], [0, 0, 1, 2, 0, 0, 0, 0]], // T-RLFF
|
||
|
|
[[1, 2, 0, 3, 4, 5, 6, 7], [0, 0, 2, 1, 0, 0, 0, 0]], // U-BBFF
|
||
|
|
[[1, 0, 2, 3, 4, 5, 6, 7], [0, 0, 2, 1, 0, 0, 0, 0]], // U-BFFB
|
||
|
|
[[2, 1, 0, 3, 4, 5, 6, 7], [0, 0, 2, 1, 0, 0, 0, 0]], // U-FFLR
|
||
|
|
[[0, 2, 1, 3, 4, 5, 6, 7], [0, 0, 2, 1, 0, 0, 0, 0]], // U-FRLF
|
||
|
|
[[2, 0, 1, 3, 4, 5, 6, 7], [0, 0, 2, 1, 0, 0, 0, 0]], // U-LFFR
|
||
|
|
[[0, 1, 2, 3, 4, 5, 6, 7], [0, 0, 2, 1, 0, 0, 0, 0]], // U-LRFF
|
||
|
|
[[2, 0, 1, 3, 4, 5, 6, 7], [1, 0, 1, 1, 0, 0, 0, 0]], // aS-FBBF
|
||
|
|
[[0, 2, 1, 3, 4, 5, 6, 7], [1, 0, 1, 1, 0, 0, 0, 0]], // aS-FBFB
|
||
|
|
[[2, 1, 0, 3, 4, 5, 6, 7], [1, 0, 1, 1, 0, 0, 0, 0]], // aS-FRFL
|
||
|
|
[[1, 2, 0, 3, 4, 5, 6, 7], [1, 0, 1, 1, 0, 0, 0, 0]], // aS-FRLF
|
||
|
|
[[0, 1, 2, 3, 4, 5, 6, 7], [1, 0, 1, 1, 0, 0, 0, 0]], // aS-LFRF
|
||
|
|
[[1, 0, 2, 3, 4, 5, 6, 7], [1, 0, 1, 1, 0, 0, 0, 0]], // aS-RFFL
|
||
|
|
[0xf, 0x0] // PLL
|
||
|
|
];
|
||
|
|
|
||
|
|
var zbprobs = [1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3];
|
||
|
|
|
||
|
|
function getZBLLScramble(type, length, filter) {
|
||
|
|
// console.log(filter);
|
||
|
|
if (filter == undefined) {
|
||
|
|
filter = ['H-BBFF', 'H-FBFB', 'H-RFLF', 'H-RLFF', 'L-FBRL', 'L-LBFF', 'L-LFFB', 'L-LFFR', 'L-LRFF', 'L-RFBL', 'Pi-BFFB', 'Pi-FBFB', 'Pi-FRFL', 'Pi-FRLF', 'Pi-LFRF', 'Pi-RFFL', 'S-FBBF', 'S-FBFB', 'S-FLFR', 'S-FLRF', 'S-LFFR', 'S-LFRF', 'T-BBFF', 'T-FBFB', 'T-FFLR', 'T-FLFR', 'T-RFLF', 'T-RLFF', 'U-BBFF', 'U-BFFB', 'U-FFLR', 'U-FRLF', 'U-LFFR', 'U-LRFF', 'aS-FBBF', 'aS-FBFB', 'aS-FRFL', 'aS-FRLF', 'aS-LFRF', 'aS-RFFL', 'PLL'];
|
||
|
|
}
|
||
|
|
var probs = zbprobs.slice();
|
||
|
|
for (var i = 0; i < probs.length; i++) {
|
||
|
|
if (!filter[i]) {
|
||
|
|
probs[i] = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var idx = mathlib.rndProb(probs);
|
||
|
|
// console.log(filter[idx]);
|
||
|
|
var zbcase = zbll_map[idx];
|
||
|
|
// console.log(zbcase);
|
||
|
|
return getAnyScramble(0xf, 0, zbcase[0], zbcase[1], [[], [Ux1], [Ux2], [Ux3]], [[], [Ux1], [Ux2], [Ux3]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getZZLLScramble() {
|
||
|
|
return getAnyScramble(0x5, 0, 0xf, 0xf, [[], [Ux1], [Ux2], [Ux3]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getZBLSScramble() {
|
||
|
|
return getAnyScramble(0x10f, 0, 0x1f, 0x1f);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getLSEScramble() {
|
||
|
|
switch (rn(4)) {
|
||
|
|
case 0:
|
||
|
|
return getAnyScramble(0xaf, 0xaf, 0, 0);
|
||
|
|
case 1:
|
||
|
|
return getAnyScramble(0xaf, 0xaf, 0, 0, [[Rx1, Lx3]]) + "x'";
|
||
|
|
case 2:
|
||
|
|
return getAnyScramble(0xaf, 0xaf, 0, 0, [[Rx2, Lx2]]) + "x2";
|
||
|
|
case 3:
|
||
|
|
return getAnyScramble(0xaf, 0xaf, 0, 0, [[Rx3, Lx1]]) + "x";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function getCMLLScramble() {
|
||
|
|
switch (rn(4)) {
|
||
|
|
case 0:
|
||
|
|
return getAnyScramble(0xaf, 0xaf, 0xf, 0xf);
|
||
|
|
case 1:
|
||
|
|
return getAnyScramble(0xaf, 0xaf, 0xf, 0xf, [[Rx1, Lx3]]) + "x'";
|
||
|
|
case 2:
|
||
|
|
return getAnyScramble(0xaf, 0xaf, 0xf, 0xf, [[Rx2, Lx2]]) + "x2";
|
||
|
|
case 3:
|
||
|
|
return getAnyScramble(0xaf, 0xaf, 0xf, 0xf, [[Rx3, Lx1]]) + "x";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function getCLLScramble() {
|
||
|
|
return getAnyScramble(0, 0, 0xf, 0xf);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getELLScramble() {
|
||
|
|
return getAnyScramble(0xf, 0xf, 0, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
function get2GLLScramble() {
|
||
|
|
return getAnyScramble(0xf, 0, 0, 0xf, [[], [Ux1], [Ux2], [Ux3]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getPLLScramble() {
|
||
|
|
return getAnyScramble(0xf, 0, 0xf, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getEOLineScramble() {
|
||
|
|
return getAnyScramble(0xf5f, 0x000, 0xff, 0xff);
|
||
|
|
}
|
||
|
|
|
||
|
|
function getEasyCrossScramble(length) {
|
||
|
|
var cases = cross.getEasyCross(length);
|
||
|
|
return getAnyScramble(cases[0], cases[1], 0xff, 0xff);
|
||
|
|
}
|
||
|
|
|
||
|
|
scramble.reg('333', getRandomScramble);
|
||
|
|
|
||
|
|
return {
|
||
|
|
/* mark2 interface */
|
||
|
|
getRandomScramble: getRandomScramble, //getRandomScramble,
|
||
|
|
|
||
|
|
/* added methods */
|
||
|
|
getEdgeScramble: getEdgeScramble,
|
||
|
|
getCornerScramble: getCornerScramble,
|
||
|
|
getLLScramble: getLLScramble,
|
||
|
|
getLSLLScramble: getLSLLScramble,
|
||
|
|
getZBLLScramble: getZBLLScramble,
|
||
|
|
getZZLLScramble: getZZLLScramble,
|
||
|
|
getF2LScramble: getF2LScramble,
|
||
|
|
getLSEScramble: getLSEScramble,
|
||
|
|
getCMLLScramble: getCMLLScramble,
|
||
|
|
getCLLScramble: getCLLScramble,
|
||
|
|
getELLScramble: getELLScramble,
|
||
|
|
getAnyScramble: getAnyScramble,
|
||
|
|
getEasyCrossScramble: getEasyCrossScramble,
|
||
|
|
|
||
|
|
getEOLineScramble: getEOLineScramble,
|
||
|
|
getZBLSScramble: getZBLSScramble,
|
||
|
|
|
||
|
|
get3BLDScramble: getRandomOriScramble,
|
||
|
|
};
|
||
|
|
})(mathlib.getNPerm, mathlib.get8Perm, mathlib.setNPerm, mathlib.set8Perm, mathlib.getNParity, mathlib.getPruning, mathlib.Cnk, mathlib.fact, mathlib.rn, mathlib.rndEl);
|