Revision 986e2221
Added by Leszek Koltunski 5 months ago
| src/main/java/org/distorted/objectlib/objects/TwistyOffsetCuboid.java | ||
|---|---|---|
| 206 | 206 |
return mAlgorithms; |
| 207 | 207 |
} |
| 208 | 208 |
|
| 209 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 210 |
|
|
| 211 |
private int computeBranchingFactor(Static3D[] axis, boolean[][] rotatable, int[][] basicAngles) |
|
| 212 |
{
|
|
| 213 |
int factor = 0; |
|
| 214 |
int numAxis = axis.length; |
|
| 215 |
|
|
| 216 |
for(int a=0; a<numAxis; a++) |
|
| 217 |
{
|
|
| 218 |
int numL = rotatable[a].length; |
|
| 219 |
|
|
| 220 |
for(int l=0; l<numL; l++) |
|
| 221 |
if( rotatable[a][l] ) |
|
| 222 |
{
|
|
| 223 |
int basicAngle = basicAngles[a][l]; |
|
| 224 |
factor += (basicAngle-1); |
|
| 225 |
} |
|
| 226 |
} |
|
| 227 |
|
|
| 228 |
return factor; |
|
| 229 |
} |
|
| 230 |
|
|
| 231 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 232 |
|
|
| 233 |
private ObjectMove[] computeMoveTable(Static3D[] axis, boolean[][] rotatable, int[][] basicAngles) |
|
| 234 |
{
|
|
| 235 |
int branchingFactor = computeBranchingFactor(axis,rotatable,basicAngles); |
|
| 236 |
ObjectMove[] ret = new ObjectMove[branchingFactor]; |
|
| 237 |
int numAxis = axis.length; |
|
| 238 |
int index = 0; |
|
| 239 |
|
|
| 240 |
for(int a=0; a<numAxis; a++) |
|
| 241 |
{
|
|
| 242 |
int numL = rotatable[a].length; |
|
| 243 |
|
|
| 244 |
for(int l=0; l<numL; l++) |
|
| 245 |
if( rotatable[a][l] ) |
|
| 246 |
{
|
|
| 247 |
int basicAngle = basicAngles[a][l]; |
|
| 248 |
for(int b=1; b<basicAngle; b++) |
|
| 249 |
{
|
|
| 250 |
int angle = b<=basicAngle/2 ? b : b-basicAngle; |
|
| 251 |
int degre = angle*360/basicAngle; |
|
| 252 |
ret[index++] = new ObjectMove( a,1<<l,degre ); |
|
| 253 |
} |
|
| 254 |
} |
|
| 255 |
} |
|
| 256 |
|
|
| 257 |
return ret; |
|
| 258 |
} |
|
| 259 |
|
|
| 209 | 260 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 210 | 261 |
|
| 211 | 262 |
private ObjectMove[][] createInitAlgs() |
| 212 | 263 |
{
|
| 264 |
Static3D[] axis = getRotationAxis(); |
|
| 265 |
boolean[][] rotatable = getLayerRotatable(); |
|
| 266 |
int[][] basic = getBasicAngles(); |
|
| 267 |
ObjectMove[] m = computeMoveTable(axis,rotatable,basic); |
|
| 268 |
|
|
| 213 | 269 |
switch( getMetadata().getParam() ) |
| 214 | 270 |
{
|
| 215 | 271 |
case I_CUBE : break; |
| 216 |
case L_CUBE : ObjectMove l41 = new ObjectMove(2,8,-90); |
|
| 217 |
ObjectMove l38 = new ObjectMove(2,4,-90); |
|
| 218 |
ObjectMove l35 = new ObjectMove(2,2,-90); |
|
| 219 |
ObjectMove l39 = new ObjectMove(2,8, 90); |
|
| 220 |
ObjectMove l36 = new ObjectMove(2,4, 90); |
|
| 221 |
ObjectMove l33 = new ObjectMove(2,2, 90); |
|
| 222 |
ObjectMove l12 = new ObjectMove(0,16,-90); |
|
| 223 |
ObjectMove l13 = new ObjectMove(0,16, 90); |
|
| 224 |
ObjectMove l14 = new ObjectMove(0,16,180); |
|
| 225 |
ObjectMove l27 = new ObjectMove(1,16,-90); |
|
| 226 |
ObjectMove l28 = new ObjectMove(1,16, 90); |
|
| 227 |
ObjectMove l29 = new ObjectMove(1,16,180); |
|
| 228 |
|
|
| 229 |
return new ObjectMove[][] |
|
| 230 |
{
|
|
| 231 |
{ l41,l12,l39,l27 },
|
|
| 232 |
{ l41,l12,l39,l28 },
|
|
| 233 |
{ l41,l12,l39,l29 },
|
|
| 234 |
{ l41,l13,l39,l27 },
|
|
| 235 |
{ l41,l13,l39,l28 },
|
|
| 236 |
{ l41,l13,l39,l29 },
|
|
| 237 |
{ l41,l14,l39,l27 },
|
|
| 238 |
{ l41,l14,l39,l28 },
|
|
| 239 |
{ l41,l14,l39,l29 },
|
|
| 240 |
{ l38,l12,l36,l27 },
|
|
| 241 |
{ l38,l12,l36,l28 },
|
|
| 242 |
{ l38,l12,l36,l29 },
|
|
| 243 |
{ l38,l13,l36,l27 },
|
|
| 244 |
{ l38,l13,l36,l28 },
|
|
| 245 |
{ l38,l13,l36,l29 },
|
|
| 246 |
{ l38,l14,l36,l27 },
|
|
| 247 |
{ l38,l14,l36,l28 },
|
|
| 248 |
{ l38,l14,l36,l29 },
|
|
| 249 |
{ l35,l12,l33,l27 },
|
|
| 250 |
{ l35,l12,l33,l28 },
|
|
| 251 |
{ l35,l12,l33,l29 },
|
|
| 252 |
{ l35,l13,l33,l27 },
|
|
| 253 |
{ l35,l13,l33,l28 },
|
|
| 254 |
{ l35,l13,l33,l29 },
|
|
| 255 |
{ l35,l14,l33,l27 },
|
|
| 256 |
{ l35,l14,l33,l28 },
|
|
| 257 |
{ l35,l14,l33,l29 },
|
|
| 258 |
}; |
|
| 259 |
case T_CUBE : break; |
|
| 260 |
case X_CUBE : break; |
|
| 272 |
case L_CUBE : ObjectMove[][] retL = new ObjectMove[27][]; |
|
| 273 |
int indexL =0; |
|
| 274 |
|
|
| 275 |
for(int m1=12; m1<15; m1++) |
|
| 276 |
for(int m2=27; m2<30; m2++) |
|
| 277 |
{
|
|
| 278 |
retL[indexL++] = new ObjectMove[] { m[41],m[m1],m[39],m[m2] };
|
|
| 279 |
retL[indexL++] = new ObjectMove[] { m[38],m[m1],m[36],m[m2] };
|
|
| 280 |
retL[indexL++] = new ObjectMove[] { m[35],m[m1],m[33],m[m2] };
|
|
| 281 |
} |
|
| 282 |
return retL; |
|
| 283 |
case T_CUBE : ObjectMove[][] retT = new ObjectMove[81][]; |
|
| 284 |
int indexT =0; |
|
| 285 |
|
|
| 286 |
for(int m1=27; m1<30; m1++) |
|
| 287 |
for(int m2=12; m2<15; m2++) |
|
| 288 |
for(int m3= 0; m3< 3; m3++) |
|
| 289 |
{
|
|
| 290 |
retT[indexT++] = new ObjectMove[] { m[m1],m[41],m[m2],m[40],m[m3],m[41] };
|
|
| 291 |
retT[indexT++] = new ObjectMove[] { m[m1],m[38],m[m2],m[37],m[m3],m[38] };
|
|
| 292 |
retT[indexT++] = new ObjectMove[] { m[m1],m[35],m[m2],m[34],m[m3],m[35] };
|
|
| 293 |
} |
|
| 294 |
return retT; |
|
| 295 |
case X_CUBE : ObjectMove[][] retX = new ObjectMove[21][]; |
|
| 296 |
int indexX =0; |
|
| 297 |
for(int m1=33; m1<42; m1++) retX[indexX++] = new ObjectMove[] { m[m1] };
|
|
| 298 |
for(int m1= 0; m1< 3; m1++) retX[indexX++] = new ObjectMove[] { m[m1] };
|
|
| 299 |
for(int m1=12; m1<15; m1++) retX[indexX++] = new ObjectMove[] { m[m1] };
|
|
| 300 |
for(int m1=27; m1<30; m1++) retX[indexX++] = new ObjectMove[] { m[m1] };
|
|
| 301 |
for(int m1=15; m1<18; m1++) retX[indexX++] = new ObjectMove[] { m[m1] };
|
|
| 302 |
return retX; |
|
| 261 | 303 |
case TRI_CUBE: break; |
| 262 | 304 |
case TEM_CUBE: break; |
| 263 | 305 |
} |
| src/main/java/org/distorted/objectlib/scrambling/ObjectScrambler.java | ||
|---|---|---|
| 69 | 69 |
private final ScrambleState[] mInitStates; |
| 70 | 70 |
private boolean mLastWasInit; |
| 71 | 71 |
private float mInitPhaseShare; |
| 72 |
private int[] mInitNumOccurences; |
|
| 72 | 73 |
|
| 73 | 74 |
// type==5 (ghosts) |
| 74 | 75 |
private int mNumNonZeroRows; |
| ... | ... | |
| 144 | 145 |
|
| 145 | 146 |
mNumOccurences = new int[max]; |
| 146 | 147 |
} |
| 148 |
|
|
| 149 |
if( mInitStates!=null && mInitNumOccurences==null ) |
|
| 150 |
{
|
|
| 151 |
int max=0; |
|
| 152 |
|
|
| 153 |
for (ScrambleState mState : mInitStates) |
|
| 154 |
{
|
|
| 155 |
int tmp = mState.getTotal(); |
|
| 156 |
if (max < tmp) max = tmp; |
|
| 157 |
} |
|
| 158 |
|
|
| 159 |
mInitNumOccurences = new int[max]; |
|
| 160 |
} |
|
| 147 | 161 |
} |
| 148 | 162 |
|
| 149 | 163 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 656 | 670 |
initializeScrambling(); |
| 657 | 671 |
} |
| 658 | 672 |
|
| 659 |
ScrambleState[] states = (mInitPhaseShare*total>=curr && mInitStates!=null) ? mInitStates : mStates; |
|
| 673 |
ScrambleState[] states; |
|
| 674 |
int[] numOccurences; |
|
| 675 |
|
|
| 676 |
if( mInitPhaseShare*total>=curr && mInitStates!=null ) |
|
| 677 |
{
|
|
| 678 |
states = mInitStates; |
|
| 679 |
numOccurences = mInitNumOccurences; |
|
| 680 |
} |
|
| 681 |
else |
|
| 682 |
{
|
|
| 683 |
states = mStates; |
|
| 684 |
numOccurences = mNumOccurences; |
|
| 685 |
} |
|
| 660 | 686 |
|
| 661 | 687 |
if( mLastWasInit && states==mStates ) |
| 662 | 688 |
{
|
| ... | ... | |
| 670 | 696 |
} |
| 671 | 697 |
else |
| 672 | 698 |
{
|
| 673 |
states[mCurrState].getRandom(rnd, mAlgorithms, mAxisExcluded, mScrambleTable, mNumOccurences, mResult);
|
|
| 699 |
states[mCurrState].getRandom(rnd, mAlgorithms, mAxisExcluded, mScrambleTable, numOccurences, mResult);
|
|
| 674 | 700 |
mCurrAlgorithm = mResult[0]; |
| 675 | 701 |
mCurrState = mResult[1]; |
| 676 | 702 |
mCurrStep = 0; |
Also available in: Unified diff
bugfix in ObjectScrambler's SCRAMBLING_TWOPHASE.