Revision 76762fba
Added by Leszek Koltunski 7 months ago
| src/main/java/org/distorted/objectlib/helpers/ObjectMove.java | ||
|---|---|---|
| 38 | 38 |
row = move.row; |
| 39 | 39 |
} |
| 40 | 40 |
|
| 41 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 42 |
|
|
| 43 |
public void setInverse(ObjectMove move) |
|
| 44 |
{
|
|
| 45 |
axis = move.axis; |
|
| 46 |
rowBitmap = move.rowBitmap; |
|
| 47 |
angle =-move.angle; |
|
| 48 |
row = move.row; |
|
| 49 |
} |
|
| 50 |
|
|
| 41 | 51 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 42 | 52 |
|
| 43 | 53 |
public void set(int ax, int rb, int ang) |
| ... | ... | |
| 48 | 58 |
row = -1; |
| 49 | 59 |
} |
| 50 | 60 |
|
| 61 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 62 |
|
|
| 63 |
public void set(int[] move) |
|
| 64 |
{
|
|
| 65 |
axis = move[0]; |
|
| 66 |
rowBitmap = move[1]; |
|
| 67 |
angle = move[2]; |
|
| 68 |
row = -1; |
|
| 69 |
} |
|
| 70 |
|
|
| 51 | 71 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 52 | 72 |
|
| 53 | 73 |
public int getAxis() { return axis; }
|
| src/main/java/org/distorted/objectlib/scrambling/ScrambleStateBandaged3x3.java | ||
|---|---|---|
| 453 | 453 |
|
| 454 | 454 |
private static String formatRet(String str, int row, int angle, long id) |
| 455 | 455 |
{
|
| 456 |
String ret = str.length()!=0 ? ",":"";
|
|
| 456 |
String ret = str.isEmpty() ? "" : ",";
|
|
| 457 | 457 |
|
| 458 | 458 |
ret += row; |
| 459 | 459 |
ret += angle<0 ? "," : ", "; |
| src/main/java/org/distorted/objectlib/scrambling/ScrambleStateLocallyBandaged.java | ||
|---|---|---|
| 9 | 9 |
|
| 10 | 10 |
package org.distorted.objectlib.scrambling; |
| 11 | 11 |
|
| 12 |
import org.distorted.objectlib.helpers.ObjectMove; |
|
| 12 | 13 |
import org.distorted.objectlib.signature.ObjectSignature; |
| 13 | 14 |
|
| 14 | 15 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 272 | 273 |
|
| 273 | 274 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 274 | 275 |
|
| 275 |
public void fillOutScramble(int[] scramble, int moveIndex)
|
|
| 276 |
public void fillOutScramble(ObjectMove scramble, int moveIndex)
|
|
| 276 | 277 |
{
|
| 277 | 278 |
for(int axis=0; axis<mNumAxis; axis++) |
| 278 | 279 |
{
|
| ... | ... | |
| 280 | 281 |
|
| 281 | 282 |
if( moveIndex<size ) |
| 282 | 283 |
{
|
| 283 |
scramble[0] = axis; |
|
| 284 |
scramble[1] = moveIndex % mSize[axis]; |
|
| 284 |
int angle = 1 ; |
|
| 285 | 285 |
|
| 286 | 286 |
switch( mTurns[axis] ) |
| 287 | 287 |
{
|
| 288 | 288 |
case 2: switch(moveIndex/mSize[axis]) |
| 289 | 289 |
{
|
| 290 |
case 0: scramble[2] =-1; break;
|
|
| 291 |
case 1: scramble[2] = 1; break;
|
|
| 290 |
case 0: angle =-1; break;
|
|
| 291 |
case 1: break; |
|
| 292 | 292 |
} |
| 293 | 293 |
break; |
| 294 | 294 |
case 3: switch(moveIndex/mSize[axis]) |
| 295 | 295 |
{
|
| 296 |
case 0: scramble[2] =-1; break;
|
|
| 297 |
case 1: scramble[2] = 2; break;
|
|
| 298 |
case 2: scramble[2] = 1; break;
|
|
| 296 |
case 0: angle =-1; break;
|
|
| 297 |
case 1: angle = 2; break;
|
|
| 298 |
case 2: break; |
|
| 299 | 299 |
} |
| 300 | 300 |
break; |
| 301 | 301 |
case 4: switch(moveIndex/mSize[axis]) |
| 302 | 302 |
{
|
| 303 |
case 0: scramble[2] =-1; break;
|
|
| 304 |
case 1: scramble[2] =-2; break;
|
|
| 305 |
case 2: scramble[2] = 2; break;
|
|
| 306 |
case 3: scramble[2] = 1; break;
|
|
| 303 |
case 0: angle =-1; break;
|
|
| 304 |
case 1: angle =-2; break;
|
|
| 305 |
case 2: angle = 2; break;
|
|
| 306 |
case 3: break; |
|
| 307 | 307 |
} |
| 308 | 308 |
break; |
| 309 |
default:scramble[2] = 1; |
|
| 310 |
System.out.println("ScrambleStateLocallyBandaged: unsupported turns: "+mTurns[axis]);
|
|
| 309 |
default:System.out.println("ScrambleStateLocallyBandaged: unsupported turns: "+mTurns[axis]);
|
|
| 311 | 310 |
} |
| 312 | 311 |
|
| 312 |
scramble.set( axis, 1<<(moveIndex % mSize[axis]), angle); |
|
| 313 | 313 |
return; |
| 314 | 314 |
} |
| 315 | 315 |
|
| src/main/java/org/distorted/objectlib/scrambling/ScrambleStateSquare1.java | ||
|---|---|---|
| 286 | 286 |
|
| 287 | 287 |
private static String formatRet(String str, int row, int angle, long id) |
| 288 | 288 |
{
|
| 289 |
String ret = str.length()!=0 ? " ,":" ";
|
|
| 289 |
String ret = str.isEmpty() ? " " : " ,";
|
|
| 290 | 290 |
|
| 291 | 291 |
ret += row; |
| 292 | 292 |
ret += ","; |
| src/main/java/org/distorted/objectlib/solvers/tablebases/TablebaseHelpers.java | ||
|---|---|---|
| 40 | 40 |
return ("move NULL!!");
|
| 41 | 41 |
} |
| 42 | 42 |
|
| 43 |
for (int[] ints : move)
|
|
| 43 |
for( int[] m : move)
|
|
| 44 | 44 |
{
|
| 45 | 45 |
sb.append(' ');
|
| 46 | 46 |
sb.append('(');
|
| 47 |
sb.append(ints[0]);
|
|
| 47 |
sb.append(m[0]);
|
|
| 48 | 48 |
sb.append(' ');
|
| 49 |
sb.append(ints[1]);
|
|
| 49 |
sb.append(m[1]);
|
|
| 50 | 50 |
sb.append(' ');
|
| 51 |
sb.append(ints[2]);
|
|
| 51 |
sb.append(m[2]);
|
|
| 52 | 52 |
sb.append(')');
|
| 53 | 53 |
} |
| 54 | 54 |
|
| src/main/java/org/distorted/objectlib/solvers/tablebases/TablebasesAbstract.java | ||
|---|---|---|
| 12 | 12 |
import org.distorted.library.helpers.QuatHelper; |
| 13 | 13 |
import org.distorted.library.type.Static3D; |
| 14 | 14 |
import org.distorted.library.type.Static4D; |
| 15 |
import org.distorted.objectlib.helpers.ObjectMove; |
|
| 15 | 16 |
import org.distorted.objectlib.helpers.OperatingSystemInterface; |
| 16 | 17 |
import org.distorted.objectlib.helpers.QuatGroupGenerator; |
| 17 | 18 |
|
| ... | ... | |
| 407 | 408 |
|
| 408 | 409 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 409 | 410 |
|
| 410 |
void convertMoves(int[][] moves)
|
|
| 411 |
ObjectMove[] convertMoves(int[][] moves)
|
|
| 411 | 412 |
{
|
| 413 |
int index = 0; |
|
| 414 |
ObjectMove[] ret = new ObjectMove[moves.length]; |
|
| 415 |
|
|
| 412 | 416 |
for(int[] move : moves ) |
| 413 | 417 |
{
|
| 414 | 418 |
int[] m = newMove(move[0],move[1],move[2]); |
| 415 |
|
|
| 416 |
move[0] = m[0]; |
|
| 417 |
move[1] = m[1]; |
|
| 418 |
move[2] = m[2]; |
|
| 419 |
ret[index++].set(m); |
|
| 419 | 420 |
} |
| 421 |
|
|
| 422 |
return ret; |
|
| 420 | 423 |
} |
| 421 | 424 |
|
| 422 | 425 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 432 | 435 |
|
| 433 | 436 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 434 | 437 |
|
| 435 |
int[][] convertMovesFromArray(ArrayList<int[]> moves)
|
|
| 438 |
ObjectMove[] convertMovesFromArray(ArrayList<int[]> moves)
|
|
| 436 | 439 |
{
|
| 437 | 440 |
int len = moves.size(); |
| 438 |
int[][] ret = new int[len][]; |
|
| 439 |
for(int i=0; i<len; i++) ret[i] = moves.get(i); |
|
| 441 |
ObjectMove[] ret = new ObjectMove[len]; |
|
| 442 |
|
|
| 443 |
for(int i=0; i<len; i++) |
|
| 444 |
{
|
|
| 445 |
int[] move = moves.get(i); |
|
| 446 |
ret[i].set(move[0],move[1],move[2]); |
|
| 447 |
} |
|
| 448 |
|
|
| 440 | 449 |
return ret; |
| 441 | 450 |
} |
| 442 | 451 |
|
| ... | ... | |
| 467 | 476 |
|
| 468 | 477 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 469 | 478 |
|
| 470 |
int[][] extraInfo(int[][] moves, int[] extra)
|
|
| 479 |
ObjectMove[] extraInfo(ObjectMove[] moves, int[] extra)
|
|
| 471 | 480 |
{
|
| 472 | 481 |
return moves; |
| 473 | 482 |
} |
| 474 | 483 |
|
| 475 | 484 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 476 | 485 |
|
| 477 |
public int[][] solution(int index, int[] extra, OperatingSystemInterface osi)
|
|
| 486 |
public ObjectMove[] solution(int index, int[] extra, OperatingSystemInterface osi)
|
|
| 478 | 487 |
{
|
| 479 | 488 |
if( !mInitialized ) return null; |
| 480 | 489 |
|
| ... | ... | |
| 544 | 553 |
} |
| 545 | 554 |
} |
| 546 | 555 |
|
| 547 |
int[][] ret = convertMovesFromArray(mMoves);
|
|
| 556 |
ObjectMove[] ret = convertMovesFromArray(mMoves);
|
|
| 548 | 557 |
return extraInfo(ret,extra); |
| 549 | 558 |
} |
| 550 | 559 |
|
| 551 | 560 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 552 | 561 |
// so that those can be overridden |
| 553 | 562 |
|
| 554 |
void postScramble(int[][] scramble, int num) { }
|
|
| 563 |
void postScramble(ObjectMove[] scramble, int num) { }
|
|
| 555 | 564 |
public void initialize() {}
|
| 556 | 565 |
|
| 557 | 566 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 558 | 567 |
|
| 559 |
public void scramble(Random rnd, int depth, int[][] scramble)
|
|
| 568 |
public void scramble(Random rnd, int depth, ObjectMove[] scramble)
|
|
| 560 | 569 |
{
|
| 561 | 570 |
if( !mInitialized ) return; |
| 562 | 571 |
|
| ... | ... | |
| 571 | 580 |
while( solDepth<depth ) |
| 572 | 581 |
{
|
| 573 | 582 |
int randomPosition = rnd.nextInt(mSize-1); |
| 574 |
int[][] sol = solution(randomPosition,cornerTwist,null);
|
|
| 583 |
ObjectMove[] sol = solution(randomPosition,cornerTwist,null);
|
|
| 575 | 584 |
solDepth = (sol!=null ? sol.length : 0); |
| 576 | 585 |
|
| 577 | 586 |
if( solDepth>=depth ) |
| 578 | 587 |
{
|
| 579 | 588 |
num = Math.min(scraLen,solDepth); |
| 580 |
|
|
| 581 |
for(int i=0; i<num; i++) |
|
| 582 |
{
|
|
| 583 |
int[] source = sol[solDepth-1-i]; |
|
| 584 |
scramble[i][0] = source[0]; |
|
| 585 |
scramble[i][1] = source[1]; |
|
| 586 |
scramble[i][2] =-source[2]; |
|
| 587 |
} |
|
| 589 |
for(int i=0; i<num; i++) scramble[i].setInverse(sol[solDepth-1-i]); |
|
| 588 | 590 |
} |
| 589 | 591 |
} |
| 590 | 592 |
|
| ... | ... | |
| 657 | 659 |
|
| 658 | 660 |
for(int i=10113000; i<19958400; i++) |
| 659 | 661 |
{
|
| 660 |
int[][] sol = solution(i,extra,os);
|
|
| 662 |
ObjectMove[] sol = solution(i,extra,os);
|
|
| 661 | 663 |
if( (i%1000)==0 ) System.out.println("solving: "+i);
|
| 662 | 664 |
} |
| 663 | 665 |
} |
| src/main/java/org/distorted/objectlib/solvers/tablebases/TablebasesPruning.java | ||
|---|---|---|
| 9 | 9 |
|
| 10 | 10 |
package org.distorted.objectlib.solvers.tablebases; |
| 11 | 11 |
|
| 12 |
import org.distorted.objectlib.helpers.ObjectMove; |
|
| 12 | 13 |
import org.distorted.objectlib.helpers.OperatingSystemInterface; |
| 13 | 14 |
|
| 14 | 15 |
import java.io.ByteArrayOutputStream; |
| ... | ... | |
| 421 | 422 |
|
| 422 | 423 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 423 | 424 |
|
| 424 |
private int[][] concatenateMoves(int[][] high, int[][] jump1, int[][] mid, int[][] jump2)
|
|
| 425 |
private ObjectMove[] concatenateMoves(int[][] high, int[][] jump1, int[][] mid, int[][] jump2)
|
|
| 425 | 426 |
{
|
| 426 | 427 |
int len1 = high ==null ? 0 : high.length-1; |
| 427 | 428 |
int len2 = jump1==null ? 0 : jump1[0][2]; |
| ... | ... | |
| 436 | 437 |
for(int i=0; i<len3; i++) moves[index++] = mid[i+1]; |
| 437 | 438 |
for(int i=0; i<len4; i++) moves[index++] = jump2[i+1]; |
| 438 | 439 |
|
| 439 |
convertMoves(moves); |
|
| 440 |
|
|
| 441 |
return moves; |
|
| 440 |
return convertMoves(moves); |
|
| 442 | 441 |
} |
| 443 | 442 |
|
| 444 | 443 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 445 | 444 |
|
| 446 |
public int[][] solution(int index, int[] extra, OperatingSystemInterface osi)
|
|
| 445 |
public ObjectMove[] solution(int index, int[] extra, OperatingSystemInterface osi)
|
|
| 447 | 446 |
{
|
| 448 | 447 |
mLastSolvingIndex = index; |
| 449 | 448 |
if( isSolved(index) ) return null; |
Also available in: Unified diff
progress