Revision 00057bb1
Added by Leszek Koltunski about 1 year ago
| src/main/java/org/distorted/objectlib/effects/fastscramble/FastScrambleEffect.java | ||
|---|---|---|
| 109 | 109 |
mObject.randomizeNewScramble(mScrambles, mRnd, scramble, mNumScrambles); |
| 110 | 110 |
} |
| 111 | 111 |
} |
| 112 |
|
|
| 113 |
for(int scramble=0; scramble<mNumScrambles; scramble++) |
|
| 114 |
{
|
|
| 115 |
int row = mScrambles[scramble][1]; |
|
| 116 |
mScrambles[scramble][1] = (1<<row); |
|
| 117 |
} |
|
| 118 | 112 |
} |
| 119 | 113 |
} |
| 120 | 114 |
|
| src/main/java/org/distorted/objectlib/effects/present/PresentEffect.java | ||
|---|---|---|
| 94 | 94 |
addNewScramble(); |
| 95 | 95 |
} |
| 96 | 96 |
|
| 97 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 98 |
|
|
| 99 |
private int computeRowFromBitmap(int rowBitmap) |
|
| 100 |
{
|
|
| 101 |
int index = 0; |
|
| 102 |
|
|
| 103 |
while(index<32) |
|
| 104 |
{
|
|
| 105 |
if( (rowBitmap&0x1) != 0 ) return index; |
|
| 106 |
rowBitmap>>=1; |
|
| 107 |
index++; |
|
| 108 |
} |
|
| 109 |
return 0; |
|
| 110 |
} |
|
| 111 |
|
|
| 97 | 112 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 98 | 113 |
|
| 99 | 114 |
private void randomizeScrambles() |
| ... | ... | |
| 103 | 118 |
for(int scramble=0; scramble<mNumScrambles; scramble++) |
| 104 | 119 |
{
|
| 105 | 120 |
mObject.randomizeNewScramble(mScrambles, mRnd, scramble, mNumScrambles); |
| 106 |
axis = mScrambles[scramble][0]; |
|
| 107 |
row = mScrambles[scramble][1]; |
|
| 108 |
angle = mScrambles[scramble][2]; |
|
| 121 |
int[] s = mScrambles[scramble]; |
|
| 122 |
axis = s[0]; |
|
| 123 |
row = computeRowFromBitmap(s[1]); |
|
| 124 |
angle = s[2]; |
|
| 109 | 125 |
absAngle = (angle<0 ? -angle : angle); |
| 110 | 126 |
basicDegrees = 360/mBasicAngle[axis][row]; |
| 111 | 127 |
totalDegrees += absAngle*basicDegrees; |
| ... | ... | |
| 175 | 191 |
|
| 176 | 192 |
if( !forward ) angle = -angle; |
| 177 | 193 |
|
| 178 |
mPre.addRotation(this, axis, (1<<row), angle, mDurationPerDegree);
|
|
| 194 |
mPre.addRotation(this, axis, row, angle, mDurationPerDegree);
|
|
| 179 | 195 |
|
| 180 | 196 |
if( forward ) mCurrScramble++; |
| 181 | 197 |
|
| src/main/java/org/distorted/objectlib/effects/scramble/ScrambleEffect.java | ||
|---|---|---|
| 85 | 85 |
abstract void createEffects(int duration, int numScrambles); |
| 86 | 86 |
abstract void effectFinishedPlugin(final long effectID); |
| 87 | 87 |
|
| 88 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 89 |
|
|
| 90 |
private int computeRowFromBitmap(int rowBitmap) |
|
| 91 |
{
|
|
| 92 |
int index = 0; |
|
| 93 |
|
|
| 94 |
while(index<32) |
|
| 95 |
{
|
|
| 96 |
if( (rowBitmap&0x1) != 0 ) return index; |
|
| 97 |
rowBitmap>>=1; |
|
| 98 |
index++; |
|
| 99 |
} |
|
| 100 |
return 0; |
|
| 101 |
} |
|
| 102 |
|
|
| 88 | 103 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 89 | 104 |
|
| 90 | 105 |
private void createBaseEffects(int duration, int numScrambles) |
| ... | ... | |
| 97 | 112 |
mObject.randomizeNewScramble(mScrambles, mRnd, scramble, numScrambles); |
| 98 | 113 |
int[] s = mScrambles[scramble]; |
| 99 | 114 |
axis = s[0]; |
| 100 |
row = s[1];
|
|
| 115 |
row = computeRowFromBitmap(s[1]);
|
|
| 101 | 116 |
angle = s[2]; |
| 102 | 117 |
absAngle = (angle<0 ? -angle : angle); |
| 103 | 118 |
basicDegrees = 360/mBasicAngle[axis][row]; |
| ... | ... | |
| 132 | 147 |
int angle= mScrambles[mNumScrambles][2]; |
| 133 | 148 |
|
| 134 | 149 |
mNumScramblesLeft--; |
| 135 |
mPre.addRotation(this, axis, (1<<row), angle, mDurationPerDegree);
|
|
| 150 |
mPre.addRotation(this, axis, row, angle, mDurationPerDegree);
|
|
| 136 | 151 |
mNumScrambles++; |
| 137 | 152 |
} |
| 138 | 153 |
else |
| src/main/java/org/distorted/objectlib/scrambling/ObjectScrambler.java | ||
|---|---|---|
| 57 | 57 |
private BlacklistedSignatures mBlacklisted; |
| 58 | 58 |
|
| 59 | 59 |
// type==3 (tablebases) |
| 60 |
private TablebasesAbstract mTablebase; |
|
| 60 |
private final TablebasesAbstract mTablebase;
|
|
| 61 | 61 |
|
| 62 | 62 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 63 | 63 |
|
| ... | ... | |
| 147 | 147 |
|
| 148 | 148 |
int[] algorithm = mAlgorithms[mCurrAlgorithm]; |
| 149 | 149 |
scramble[curr][0] = algorithm[mCurrStep ]; |
| 150 |
scramble[curr][1] = algorithm[mCurrStep+1];
|
|
| 150 |
scramble[curr][1] = (1<<algorithm[mCurrStep+1]);
|
|
| 151 | 151 |
scramble[curr][2] = algorithm[mCurrStep+2]; |
| 152 | 152 |
|
| 153 | 153 |
mAxisExcluded = algorithm[0]; |
| ... | ... | |
| 401 | 401 |
scramble[curr][2] = nextAngle; |
| 402 | 402 |
mLastRot = layer==0 ? LAST_LO : LAST_UP; |
| 403 | 403 |
updateCornerQuats(scramble[curr]); |
| 404 |
scramble[curr][1] = (1<<scramble[curr][1]); |
|
| 404 | 405 |
break; |
| 405 | 406 |
case LAST_LO: |
| 406 | 407 |
case LAST_UP: layer = mLastRot==LAST_LO ? 1:0; |
| ... | ... | |
| 412 | 413 |
scramble[curr][1] = 2*layer; |
| 413 | 414 |
scramble[curr][2] = nextAngle; |
| 414 | 415 |
updateCornerQuats(scramble[curr]); |
| 416 |
scramble[curr][1] = (1<<scramble[curr][1]); |
|
| 415 | 417 |
mLastRot = LAST_UL; |
| 416 | 418 |
} |
| 417 | 419 |
else |
| ... | ... | |
| 421 | 423 |
scramble[curr][2] = 1; |
| 422 | 424 |
mLastRot = LAST_SL; |
| 423 | 425 |
updateCornerQuats(scramble[curr]); |
| 426 |
scramble[curr][1] = (1<<scramble[curr][1]); |
|
| 424 | 427 |
computePermittedAngles(); |
| 425 | 428 |
} |
| 426 | 429 |
|
| ... | ... | |
| 431 | 434 |
mLastRot = LAST_SL; |
| 432 | 435 |
updateCornerQuats(scramble[curr]); |
| 433 | 436 |
computePermittedAngles(); |
| 437 |
scramble[curr][1] = (1<<scramble[curr][1]); |
|
| 434 | 438 |
break; |
| 435 | 439 |
} |
| 436 | 440 |
} |
| ... | ... | |
| 617 | 621 |
|
| 618 | 622 |
private void randomizeNewScramble2(int[][] scramble, Random rnd, int curr, int total, ObjectSignature signature) |
| 619 | 623 |
{
|
| 620 |
if( curr==0 ) initializeType2Scrambling(scramble,rnd,total,signature); |
|
| 624 |
if( curr==0 ) |
|
| 625 |
{
|
|
| 626 |
initializeType2Scrambling(scramble,rnd,total,signature); |
|
| 627 |
int len = scramble.length; |
|
| 628 |
for(int i=0; i<len; i++) scramble[i][1] = (1<<scramble[i][1]); |
|
| 629 |
} |
|
| 621 | 630 |
} |
| 622 | 631 |
|
| 623 | 632 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/tablebases/TablebasesAbstract.java | ||
|---|---|---|
| 124 | 124 |
} |
| 125 | 125 |
} |
| 126 | 126 |
|
| 127 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 128 |
|
|
| 129 |
private int computeRowFromBitmap(int rowBitmap) |
|
| 130 |
{
|
|
| 131 |
int index = 0; |
|
| 132 |
|
|
| 133 |
while(index<32) |
|
| 134 |
{
|
|
| 135 |
if( (rowBitmap&0x1) != 0 ) return index; |
|
| 136 |
rowBitmap>>=1; |
|
| 137 |
index++; |
|
| 138 |
} |
|
| 139 |
return 0; |
|
| 140 |
} |
|
| 141 |
|
|
| 142 | 127 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 143 | 128 |
|
| 144 | 129 |
private int computeRow(float[] pos, int quat, int axisIndex) |
| ... | ... | |
| 483 | 468 |
{
|
| 484 | 469 |
int[] source = sol[solDepth-1-i]; |
| 485 | 470 |
scramble[i][0] = source[0]; |
| 486 |
scramble[i][1] = computeRowFromBitmap(source[1]);
|
|
| 471 |
scramble[i][1] = source[1];
|
|
| 487 | 472 |
scramble[i][2] =-source[2]; |
| 488 | 473 |
} |
| 489 | 474 |
} |
Also available in: Unified diff
Make it possible to return rowBitmaps from ObjectScrambler (rather than single rows)