Revision a57e6870
Added by Leszek Koltunski over 2 years ago
| src/main/java/org/distorted/objectlib/objects/TwistyKilominx.java | ||
|---|---|---|
| 45 | 45 |
|
| 46 | 46 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 47 | 47 |
|
| 48 |
public TwistyKilominx(int size, Static4D quat, Static3D move, DistortedTexture texture,
|
|
| 48 |
public TwistyKilominx(int[] numL, Static4D quat, Static3D move, DistortedTexture texture,
|
|
| 49 | 49 |
MeshSquare mesh, DistortedEffects effects, Resources res, int scrWidth) |
| 50 | 50 |
{
|
| 51 |
super(size, size, quat, move, texture, mesh, effects, res, scrWidth);
|
|
| 51 |
super(numL, quat, move, texture, mesh, effects, res, scrWidth);
|
|
| 52 | 52 |
} |
| 53 | 53 |
|
| 54 | 54 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 88 | 88 |
|
| 89 | 89 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 90 | 90 |
|
| 91 |
protected int getResource(int numLayers) |
|
| 91 |
protected int getResource(int[] numLayers)
|
|
| 92 | 92 |
{
|
| 93 |
switch(numLayers) |
|
| 93 |
switch(numLayers[0])
|
|
| 94 | 94 |
{
|
| 95 | 95 |
case 3: return R.raw.kilo3; |
| 96 | 96 |
case 5: return R.raw.kilo5; |
| ... | ... | |
| 101 | 101 |
|
| 102 | 102 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 103 | 103 |
|
| 104 |
protected int getNumStickerTypes(int numLayers) |
|
| 104 |
protected int getNumStickerTypes(int[] numLayers)
|
|
| 105 | 105 |
{
|
| 106 |
return numLayers<5 ? 1 : numLayers/2 + 1; |
|
| 106 |
int numL = numLayers[0]; |
|
| 107 |
return numL<5 ? 1 : numL/2 + 1; |
|
| 107 | 108 |
} |
| 108 | 109 |
|
| 109 | 110 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 110 | 111 |
|
| 111 |
protected float[][] getCuts(int numLayers) |
|
| 112 |
protected float[][] getCuts(int[] numLayers)
|
|
| 112 | 113 |
{
|
| 113 |
return genericGetCuts(numLayers,0.5f); |
|
| 114 |
return genericGetCuts(numLayers[0],0.5f);
|
|
| 114 | 115 |
} |
| 115 | 116 |
|
| 116 | 117 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 247 | 248 |
|
| 248 | 249 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 249 | 250 |
|
| 250 |
protected float[][] getCubitPositions(int numLayers) |
|
| 251 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
| 251 | 252 |
{
|
| 252 | 253 |
if( mCorners==null ) initializeCorners(); |
| 253 |
if( numLayers<5 ) return mCorners; |
|
| 254 | 254 |
|
| 255 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
|
| 256 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers); |
|
| 255 |
int numL = numLayers[0]; |
|
| 256 |
if( numL<5 ) return mCorners; |
|
| 257 |
|
|
| 258 |
int numCubitsPerCorner = numCubitsPerCorner(numL); |
|
| 259 |
int numCubitsPerEdge = numCubitsPerEdge(numL); |
|
| 257 | 260 |
int numCubitsPerCenter = 5; |
| 258 | 261 |
int numCubits = NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge + NUM_CENTERS*numCubitsPerCenter; |
| 259 | 262 |
int index=0; |
| ... | ... | |
| 266 | 269 |
|
| 267 | 270 |
for(int part=0; part<numCubitsPerCorner; part++, index++) |
| 268 | 271 |
{
|
| 269 |
CENTERS[index] = computeCorner(numCubitsPerCorner,numLayers,corner,part);
|
|
| 272 |
CENTERS[index] = computeCorner(numCubitsPerCorner,numL,corner,part); |
|
| 270 | 273 |
} |
| 271 | 274 |
} |
| 272 | 275 |
|
| ... | ... | |
| 274 | 277 |
{
|
| 275 | 278 |
for(int part=0; part<numCubitsPerEdge; part++, index++) |
| 276 | 279 |
{
|
| 277 |
CENTERS[index] = computeEdge(numLayers, edge, part );
|
|
| 280 |
CENTERS[index] = computeEdge(numL, edge, part ); |
|
| 278 | 281 |
} |
| 279 | 282 |
} |
| 280 | 283 |
|
| ... | ... | |
| 282 | 285 |
{
|
| 283 | 286 |
for(int part=0; part<numCubitsPerCenter; part++, index++) |
| 284 | 287 |
{
|
| 285 |
CENTERS[index] = computeCenter(numLayers,center, part);
|
|
| 288 |
CENTERS[index] = computeCenter(numL,center, part); |
|
| 286 | 289 |
} |
| 287 | 290 |
} |
| 288 | 291 |
|
| ... | ... | |
| 325 | 328 |
|
| 326 | 329 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 327 | 330 |
|
| 328 |
protected ObjectShape getObjectShape(int cubit, int numLayers) |
|
| 331 |
protected ObjectShape getObjectShape(int cubit, int[] numLayers)
|
|
| 329 | 332 |
{
|
| 333 |
int numL = numLayers[0]; |
|
| 330 | 334 |
int variant = getCubitVariant(cubit,numLayers); |
| 331 | 335 |
int numVariants = getNumCubitVariants(numLayers); |
| 332 | 336 |
|
| 333 |
if( variant==0 && numLayers>3 )
|
|
| 337 |
if( variant==0 && numL>3 ) |
|
| 334 | 338 |
{
|
| 335 |
float width = numLayers/(numLayers-1.0f);
|
|
| 339 |
float width = numL/(numL-1.0f);
|
|
| 336 | 340 |
float A = (2*SQ3/3)*SIN54; |
| 337 | 341 |
float B = 0.4f; |
| 338 | 342 |
double X = width*COS18*SIN_HALFD; |
| ... | ... | |
| 377 | 381 |
} |
| 378 | 382 |
if( variant<numVariants-1 ) |
| 379 | 383 |
{
|
| 380 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers);
|
|
| 381 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers);
|
|
| 384 |
int numCubitsPerCorner = numCubitsPerCorner(numL); |
|
| 385 |
int numCubitsPerEdge = numCubitsPerEdge(numL); |
|
| 382 | 386 |
int type = computeEdgeType(cubit,numCubitsPerCorner,numCubitsPerEdge); |
| 383 |
float tmpVal= numLayers/(numLayers-1.0f);
|
|
| 387 |
float tmpVal= numL/(numL-1.0f);
|
|
| 384 | 388 |
float height= tmpVal*COS18; |
| 385 | 389 |
float width = tmpVal + (type/2)*tmpVal*SIN18; |
| 386 | 390 |
boolean left = (type%2)==0; |
| ... | ... | |
| 428 | 432 |
} |
| 429 | 433 |
} |
| 430 | 434 |
|
| 431 |
int numBands0 = numLayers<=5 ? 4 : 3;
|
|
| 432 |
int numBands1 = numLayers<=5 ? 3 : 2;
|
|
| 435 |
int numBands0 = numL<=5 ? 4 : 3; |
|
| 436 |
int numBands1 = numL<=5 ? 3 : 2; |
|
| 433 | 437 |
|
| 434 |
float[][] bands = new float[][]
|
|
| 438 |
float[][] bands = new float[][] |
|
| 435 | 439 |
{
|
| 436 | 440 |
{0.04f,34,0.2f,0.2f,numBands0,1,1},
|
| 437 | 441 |
{0.00f, 0,0.0f,0.0f,numBands1,0,0}
|
| ... | ... | |
| 447 | 451 |
} |
| 448 | 452 |
else |
| 449 | 453 |
{
|
| 450 |
float width = (1+0.5f*(numLayers-3)*SIN18)*numLayers/(numLayers-1);
|
|
| 454 |
float width = (1+0.5f*(numL-3)*SIN18)*numL/(numL-1);
|
|
| 451 | 455 |
|
| 452 | 456 |
double X = width*COS18*SIN_HALFD; |
| 453 | 457 |
double Y = width*SIN18; |
| ... | ... | |
| 457 | 461 |
double X3= H*SIN_HALFD; |
| 458 | 462 |
double Z3= H*COS_HALFD; |
| 459 | 463 |
double C = 1/(COS54*Math.sqrt(2-2*SIN18)); |
| 460 |
int N = numLayers==3 ? 4 : 3;
|
|
| 461 |
int E = numLayers==3 ? 1 : 0;
|
|
| 464 |
int N = numL==3 ? 4 : 3; |
|
| 465 |
int E = numL==3 ? 1 : 0; |
|
| 462 | 466 |
|
| 463 | 467 |
double[][] vertices = new double[][] |
| 464 | 468 |
{
|
| ... | ... | |
| 503 | 507 |
|
| 504 | 508 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 505 | 509 |
|
| 506 |
protected Static4D getQuat(int cubit, int numLayers) |
|
| 510 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
| 507 | 511 |
{
|
| 508 | 512 |
if( mQuats==null ) initializeQuats(); |
| 509 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
|
| 510 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers); |
|
| 513 |
|
|
| 514 |
int numL = numLayers[0]; |
|
| 515 |
int numCubitsPerCorner = numCubitsPerCorner(numL); |
|
| 516 |
int numCubitsPerEdge = numCubitsPerEdge(numL); |
|
| 511 | 517 |
|
| 512 | 518 |
return mQuats[getQuat(cubit,numCubitsPerCorner,numCubitsPerEdge)]; |
| 513 | 519 |
} |
| 514 | 520 |
|
| 515 | 521 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 516 | 522 |
|
| 517 |
protected int getNumCubitVariants(int numLayers) |
|
| 523 |
protected int getNumCubitVariants(int[] numLayers)
|
|
| 518 | 524 |
{
|
| 519 |
switch(numLayers) |
|
| 525 |
switch(numLayers[0])
|
|
| 520 | 526 |
{
|
| 521 | 527 |
case 3: return 1; |
| 522 | 528 |
case 5: return 4; |
| ... | ... | |
| 527 | 533 |
|
| 528 | 534 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 529 | 535 |
|
| 530 |
protected int getCubitVariant(int cubit, int numLayers) |
|
| 536 |
protected int getCubitVariant(int cubit, int[] numLayers)
|
|
| 531 | 537 |
{
|
| 532 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
|
| 538 |
int numL = numLayers[0]; |
|
| 539 |
int numCubitsPerCorner = numCubitsPerCorner(numL); |
|
| 533 | 540 |
|
| 534 | 541 |
if( cubit<NUM_CORNERS*numCubitsPerCorner ) return 0; |
| 535 | 542 |
|
| 536 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers);
|
|
| 543 |
int numCubitsPerEdge = numCubitsPerEdge(numL);
|
|
| 537 | 544 |
|
| 538 | 545 |
if( cubit<NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge ) |
| 539 | 546 |
{
|
| ... | ... | |
| 619 | 626 |
|
| 620 | 627 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 621 | 628 |
|
| 622 |
protected int getFaceColor(int cubit, int cubitface, int numLayers) |
|
| 629 |
protected int getFaceColor(int cubit, int cubitface, int[] numLayers)
|
|
| 623 | 630 |
{
|
| 624 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
|
| 625 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers); |
|
| 631 |
int numL = numLayers[0]; |
|
| 632 |
int numCubitsPerCorner = numCubitsPerCorner(numL); |
|
| 633 |
int numCubitsPerEdge = numCubitsPerEdge(numL); |
|
| 626 | 634 |
|
| 627 | 635 |
if( cubit < NUM_CORNERS*numCubitsPerCorner ) |
| 628 | 636 |
{
|
| 629 |
return getCornerColor(cubit,cubitface,numLayers,numCubitsPerCorner);
|
|
| 637 |
return getCornerColor(cubit,cubitface,numL,numCubitsPerCorner); |
|
| 630 | 638 |
} |
| 631 | 639 |
else if( cubit<NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge ) |
| 632 | 640 |
{
|
| ... | ... | |
| 636 | 644 |
else |
| 637 | 645 |
{
|
| 638 | 646 |
int center = cubit-NUM_CORNERS*numCubitsPerCorner-NUM_EDGES*numCubitsPerEdge; |
| 639 |
return getCenterColor( center, cubitface, numLayers);
|
|
| 647 |
return getCenterColor( center, cubitface, numL); |
|
| 640 | 648 |
} |
| 641 | 649 |
} |
| 642 | 650 |
|
| ... | ... | |
| 676 | 684 |
|
| 677 | 685 |
if( ObjectControl.isInIconMode() ) |
| 678 | 686 |
{
|
| 679 |
float mult = getNumLayers()==3 ? 1.0f : 1.5f; |
|
| 687 |
int[] numLayers = getNumLayers(); |
|
| 688 |
float mult = numLayers[0]==3 ? 1.0f : 1.5f; |
|
| 680 | 689 |
|
| 681 | 690 |
strokes[0]*=mult; |
| 682 | 691 |
strokes[1]*=mult; |
| ... | ... | |
| 697 | 706 |
private int getStickerIndex(int face) |
| 698 | 707 |
{
|
| 699 | 708 |
int variant = face/NUM_FACE_COLORS; |
| 700 |
int numLayers = getNumLayers(); |
|
| 709 |
int[] numLayers = getNumLayers(); |
|
| 710 |
int numL = numLayers[0]; |
|
| 701 | 711 |
|
| 702 |
if( variant == (numLayers-1)/2 || numLayers==3 ) return 0;
|
|
| 712 |
if( variant == (numL-1)/2 || numL==3 ) return 0;
|
|
| 703 | 713 |
if( variant==0 ) return 1; |
| 704 | 714 |
|
| 705 | 715 |
return 2; |
| ... | ... | |
| 707 | 717 |
|
| 708 | 718 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 709 | 719 |
|
| 710 |
public ObjectType intGetObjectType(int numLayers) |
|
| 720 |
public ObjectType intGetObjectType(int[] numLayers)
|
|
| 711 | 721 |
{
|
| 712 |
switch(numLayers) |
|
| 722 |
switch(numLayers[0])
|
|
| 713 | 723 |
{
|
| 714 | 724 |
case 3: return ObjectType.KILO_3; |
| 715 | 725 |
case 5: return ObjectType.KILO_5; |
| ... | ... | |
| 720 | 730 |
|
| 721 | 731 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 722 | 732 |
|
| 723 |
public int getObjectName(int numLayers) |
|
| 733 |
public int getObjectName(int[] numLayers)
|
|
| 724 | 734 |
{
|
| 725 |
if( numLayers==3 ) return R.string.minx2; |
|
| 726 |
if( numLayers==5 ) return R.string.minx4; |
|
| 735 |
int numL = numLayers[0]; |
|
| 736 |
|
|
| 737 |
if( numL==3 ) return R.string.minx2; |
|
| 738 |
if( numL==5 ) return R.string.minx4; |
|
| 727 | 739 |
|
| 728 | 740 |
return 0; |
| 729 | 741 |
} |
| 730 | 742 |
|
| 731 | 743 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 732 | 744 |
|
| 733 |
public int getInventor(int numLayers) |
|
| 745 |
public int getInventor(int[] numLayers)
|
|
| 734 | 746 |
{
|
| 735 |
if( numLayers==3 ) return R.string.minx2_inventor; |
|
| 736 |
if( numLayers==5 ) return R.string.minx4_inventor; |
|
| 747 |
int numL = numLayers[0]; |
|
| 748 |
|
|
| 749 |
if( numL==3 ) return R.string.minx2_inventor; |
|
| 750 |
if( numL==5 ) return R.string.minx4_inventor; |
|
| 737 | 751 |
|
| 738 | 752 |
return 0; |
| 739 | 753 |
} |
| 740 | 754 |
|
| 741 | 755 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 742 | 756 |
|
| 743 |
public int getComplexity(int numLayers) |
|
| 757 |
public int getComplexity(int[] numLayers)
|
|
| 744 | 758 |
{
|
| 745 |
return 3; |
|
| 759 |
int numL = numLayers[0]; |
|
| 760 |
|
|
| 761 |
if( numL==3 ) return 5; |
|
| 762 |
if( numL==5 ) return 8; |
|
| 763 |
|
|
| 764 |
return 8; |
|
| 746 | 765 |
} |
| 747 | 766 |
} |
Also available in: Unified diff
make numLayers into an int[] (preparation for Cuboids)
Caution: because of previous changes to cubit order in cube, the Solver is broken!