Revision a57e6870
Added by Leszek Koltunski over 2 years ago
| src/main/java/org/distorted/objectlib/objects/TwistyMegaminx.java | ||
|---|---|---|
| 46 | 46 |
|
| 47 | 47 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 48 | 48 |
|
| 49 |
public TwistyMegaminx(int size, Static4D quat, Static3D move, DistortedTexture texture,
|
|
| 49 |
public TwistyMegaminx(int[] numL, Static4D quat, Static3D move, DistortedTexture texture,
|
|
| 50 | 50 |
MeshSquare mesh, DistortedEffects effects, Resources res, int scrWidth) |
| 51 | 51 |
{
|
| 52 |
super(size, size, quat, move, texture, mesh, effects, res, scrWidth);
|
|
| 52 |
super(numL, quat, move, texture, mesh, effects, res, scrWidth);
|
|
| 53 | 53 |
} |
| 54 | 54 |
|
| 55 | 55 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 75 | 75 |
|
| 76 | 76 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 77 | 77 |
|
| 78 |
protected int getResource(int numLayers) |
|
| 78 |
protected int getResource(int[] numLayers)
|
|
| 79 | 79 |
{
|
| 80 |
switch(numLayers) |
|
| 80 |
switch(numLayers[0])
|
|
| 81 | 81 |
{
|
| 82 | 82 |
case 3: return R.raw.mega3; |
| 83 | 83 |
case 5: return R.raw.mega5; |
| ... | ... | |
| 88 | 88 |
|
| 89 | 89 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 90 | 90 |
|
| 91 |
protected int getNumStickerTypes(int numLayers) |
|
| 91 |
protected int getNumStickerTypes(int[] numLayers)
|
|
| 92 | 92 |
{
|
| 93 |
return (numLayers+3)/2; |
|
| 93 |
return (numLayers[0]+3)/2;
|
|
| 94 | 94 |
} |
| 95 | 95 |
|
| 96 | 96 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 97 | 97 |
|
| 98 |
protected float[][] getCuts(int numLayers) |
|
| 98 |
protected float[][] getCuts(int[] numLayers)
|
|
| 99 | 99 |
{
|
| 100 |
return genericGetCuts(numLayers,0.5f-MEGA_D); |
|
| 100 |
return genericGetCuts(numLayers[0],0.5f-MEGA_D);
|
|
| 101 | 101 |
} |
| 102 | 102 |
|
| 103 | 103 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 209 | 209 |
|
| 210 | 210 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 211 | 211 |
|
| 212 |
protected float[][] getCubitPositions(int numLayers) |
|
| 212 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
| 213 | 213 |
{
|
| 214 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
|
| 215 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers); |
|
| 214 |
int numL = numLayers[0]; |
|
| 215 |
int numCubitsPerCorner = numCubitsPerCorner(numL); |
|
| 216 |
int numCubitsPerEdge = numCubitsPerEdge(numL); |
|
| 216 | 217 |
int numCubits = NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge + NUM_CENTERS; |
| 217 | 218 |
int index=0; |
| 218 | 219 |
|
| ... | ... | |
| 224 | 225 |
|
| 225 | 226 |
for(int part=0; part<numCubitsPerCorner; part++, index++) |
| 226 | 227 |
{
|
| 227 |
CENTERS[index] = computeCorner(numCubitsPerCorner,numLayers,corner,part);
|
|
| 228 |
CENTERS[index] = computeCorner(numCubitsPerCorner,numL,corner,part); |
|
| 228 | 229 |
} |
| 229 | 230 |
} |
| 230 | 231 |
|
| ... | ... | |
| 232 | 233 |
{
|
| 233 | 234 |
for(int part=0; part<numCubitsPerEdge; part++, index++) |
| 234 | 235 |
{
|
| 235 |
CENTERS[index] = computeEdge(numLayers, edge, part );
|
|
| 236 |
CENTERS[index] = computeEdge(numL, edge, part ); |
|
| 236 | 237 |
} |
| 237 | 238 |
} |
| 238 | 239 |
|
| 239 | 240 |
for(int center=0; center<NUM_CENTERS; center++, index++) |
| 240 | 241 |
{
|
| 241 |
CENTERS[index] = computeCenter(center, numLayers);
|
|
| 242 |
CENTERS[index] = computeCenter(center, numL); |
|
| 242 | 243 |
} |
| 243 | 244 |
|
| 244 | 245 |
return CENTERS; |
| ... | ... | |
| 269 | 270 |
|
| 270 | 271 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 271 | 272 |
|
| 272 |
protected ObjectShape getObjectShape(int cubit, int numLayers) |
|
| 273 |
protected ObjectShape getObjectShape(int cubit, int[] numLayers)
|
|
| 273 | 274 |
{
|
| 275 |
int numL = numLayers[0]; |
|
| 274 | 276 |
int variant = getCubitVariant(cubit,numLayers); |
| 275 | 277 |
int numVariants = getNumCubitVariants(numLayers); |
| 276 | 278 |
|
| 277 | 279 |
if( variant==0 ) |
| 278 | 280 |
{
|
| 279 |
float width = numLayers*(0.5f-MEGA_D)/(0.5f*(numLayers-1));
|
|
| 281 |
float width = numL*(0.5f-MEGA_D)/(0.5f*(numL-1));
|
|
| 280 | 282 |
float A = (2*SQ3/3)*SIN54; |
| 281 | 283 |
float B = 0.4f; |
| 282 | 284 |
double X = width*COS18*SIN_HALFD; |
| 283 | 285 |
double Y = width*SIN18; |
| 284 | 286 |
double Z = width*COS18*COS_HALFD; |
| 285 |
int N = numLayers==3 ? 1:0;
|
|
| 287 |
int N = numL==3 ? 1:0; |
|
| 286 | 288 |
|
| 287 | 289 |
double[][] vertices = new double[][] |
| 288 | 290 |
{
|
| ... | ... | |
| 322 | 324 |
} |
| 323 | 325 |
if( variant<numVariants-1 ) |
| 324 | 326 |
{
|
| 325 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers);
|
|
| 326 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers);
|
|
| 327 |
int numCubitsPerCorner = numCubitsPerCorner(numL); |
|
| 328 |
int numCubitsPerEdge = numCubitsPerEdge(numL); |
|
| 327 | 329 |
int type = computeEdgeType(cubit,numCubitsPerCorner,numCubitsPerEdge); |
| 328 |
float height= numLayers*(0.5f-MEGA_D)*COS18/((numLayers-1)*0.5f);
|
|
| 329 |
float width = numLayers*2*MEGA_D + 2*type*height*SIN18/COS18;
|
|
| 330 |
float height= numL*(0.5f-MEGA_D)*COS18/((numL-1)*0.5f);
|
|
| 331 |
float width = numL*2*MEGA_D + 2*type*height*SIN18/COS18; |
|
| 330 | 332 |
|
| 331 | 333 |
double W = width/2; |
| 332 | 334 |
double X = height*SIN_HALFD; |
| ... | ... | |
| 355 | 357 |
{4,5,6,7}
|
| 356 | 358 |
}; |
| 357 | 359 |
|
| 358 |
int N = numLayers<=5 ? 5 : 3;
|
|
| 360 |
int N = numL<=5 ? 5 : 3; |
|
| 359 | 361 |
|
| 360 |
float[][] bands = new float[][]
|
|
| 362 |
float[][] bands = new float[][] |
|
| 361 | 363 |
{
|
| 362 | 364 |
{0.04f,34,0.2f,0.2f,N,0,0},
|
| 363 | 365 |
{0.00f, 0,0.3f,0.2f,2,0,0}
|
| ... | ... | |
| 372 | 374 |
} |
| 373 | 375 |
else |
| 374 | 376 |
{
|
| 375 |
float width = 2*numLayers*(MEGA_D+(0.5f-MEGA_D)*SIN18);
|
|
| 377 |
float width = 2*numL*(MEGA_D+(0.5f-MEGA_D)*SIN18); |
|
| 376 | 378 |
final double V = 0.83; // ?? |
| 377 | 379 |
final double ANGLE = V*Math.PI; |
| 378 | 380 |
final double cosA = Math.cos(ANGLE); |
| ... | ... | |
| 399 | 401 |
{0,1,2,3,4}
|
| 400 | 402 |
}; |
| 401 | 403 |
|
| 402 |
int N = numLayers==3 ? 4 : 3;
|
|
| 404 |
int N = numL==3 ? 4 : 3; |
|
| 403 | 405 |
|
| 404 | 406 |
float[][] bands = new float[][] |
| 405 | 407 |
{
|
| ... | ... | |
| 419 | 421 |
|
| 420 | 422 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 421 | 423 |
|
| 422 |
protected Static4D getQuat(int cubit, int numLayers) |
|
| 424 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
| 423 | 425 |
{
|
| 424 | 426 |
if( mQuats==null ) initializeQuats(); |
| 425 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
|
| 426 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers); |
|
| 427 |
|
|
| 428 |
int numL = numLayers[0]; |
|
| 429 |
int numCubitsPerCorner = numCubitsPerCorner(numL); |
|
| 430 |
int numCubitsPerEdge = numCubitsPerEdge(numL); |
|
| 427 | 431 |
|
| 428 | 432 |
return mQuats[getQuat(cubit,numCubitsPerCorner,numCubitsPerEdge)]; |
| 429 | 433 |
} |
| 430 | 434 |
|
| 431 | 435 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 432 | 436 |
|
| 433 |
protected int getNumCubitVariants(int numLayers) |
|
| 437 |
protected int getNumCubitVariants(int[] numLayers)
|
|
| 434 | 438 |
{
|
| 435 |
switch(numLayers) |
|
| 439 |
switch(numLayers[0])
|
|
| 436 | 440 |
{
|
| 437 | 441 |
case 3: return 3; |
| 438 | 442 |
case 5: return 4; |
| ... | ... | |
| 443 | 447 |
|
| 444 | 448 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 445 | 449 |
|
| 446 |
protected int getCubitVariant(int cubit, int numLayers) |
|
| 450 |
protected int getCubitVariant(int cubit, int[] numLayers)
|
|
| 447 | 451 |
{
|
| 448 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
|
| 452 |
int numL = numLayers[0]; |
|
| 453 |
int numCubitsPerCorner = numCubitsPerCorner(numL); |
|
| 449 | 454 |
|
| 450 | 455 |
if( cubit<NUM_CORNERS*numCubitsPerCorner ) return 0; |
| 451 | 456 |
|
| 452 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers);
|
|
| 457 |
int numCubitsPerEdge = numCubitsPerEdge(numL);
|
|
| 453 | 458 |
|
| 454 | 459 |
if( cubit<NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge ) |
| 455 | 460 |
{
|
| ... | ... | |
| 525 | 530 |
|
| 526 | 531 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 527 | 532 |
|
| 528 |
protected int getFaceColor(int cubit, int cubitface, int numLayers) |
|
| 533 |
protected int getFaceColor(int cubit, int cubitface, int[] numLayers)
|
|
| 529 | 534 |
{
|
| 530 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
|
| 531 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers); |
|
| 535 |
int numL = numLayers[0]; |
|
| 536 |
int numCubitsPerCorner = numCubitsPerCorner(numL); |
|
| 537 |
int numCubitsPerEdge = numCubitsPerEdge(numL); |
|
| 532 | 538 |
|
| 533 | 539 |
if( cubit < NUM_CORNERS*numCubitsPerCorner ) |
| 534 | 540 |
{
|
| 535 |
return getCornerColor(cubit,cubitface,numLayers,numCubitsPerCorner);
|
|
| 541 |
return getCornerColor(cubit,cubitface,numL,numCubitsPerCorner); |
|
| 536 | 542 |
} |
| 537 | 543 |
else if( cubit<NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge ) |
| 538 | 544 |
{
|
| ... | ... | |
| 542 | 548 |
else |
| 543 | 549 |
{
|
| 544 | 550 |
int center = cubit-NUM_CORNERS*numCubitsPerCorner-NUM_EDGES*numCubitsPerEdge; |
| 545 |
return getCenterColor( center, cubitface, numLayers);
|
|
| 551 |
return getCenterColor( center, cubitface, numL); |
|
| 546 | 552 |
} |
| 547 | 553 |
} |
| 548 | 554 |
|
| ... | ... | |
| 573 | 579 |
|
| 574 | 580 |
if( ObjectControl.isInIconMode() ) |
| 575 | 581 |
{
|
| 576 |
float mult = getNumLayers()==3 ? 1.5f : 2.2f; |
|
| 582 |
int[] numLayers = getNumLayers(); |
|
| 583 |
float mult = numLayers[0]==3 ? 1.5f : 2.2f; |
|
| 577 | 584 |
|
| 578 | 585 |
strokes[0]*=mult; |
| 579 | 586 |
strokes[1]*=mult; |
| ... | ... | |
| 599 | 606 |
|
| 600 | 607 |
if( variant==0 ) return 0; |
| 601 | 608 |
|
| 602 |
int numLayers = getNumLayers(); |
|
| 609 |
int[] numLayers = getNumLayers(); |
|
| 610 |
int numL = numLayers[0]; |
|
| 603 | 611 |
|
| 604 |
if( variant < (numLayers+1)/2 )
|
|
| 612 |
if( variant < (numL+1)/2 ) |
|
| 605 | 613 |
{
|
| 606 |
if( numLayers==3 ) return 1; |
|
| 607 |
else |
|
| 608 |
{
|
|
| 609 |
if( variant==1 ) return 2; |
|
| 610 |
else return 3; |
|
| 611 |
} |
|
| 614 |
return numL==3 ? 1 : ( variant==1 ? 2 : 3 ); |
|
| 612 | 615 |
} |
| 613 | 616 |
|
| 614 | 617 |
return 4; |
| ... | ... | |
| 616 | 619 |
|
| 617 | 620 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 618 | 621 |
|
| 619 |
public ObjectType intGetObjectType(int numLayers) |
|
| 622 |
public ObjectType intGetObjectType(int[] numLayers)
|
|
| 620 | 623 |
{
|
| 621 |
switch(numLayers) |
|
| 624 |
switch(numLayers[0])
|
|
| 622 | 625 |
{
|
| 623 | 626 |
case 3: return ObjectType.MEGA_3; |
| 624 | 627 |
case 5: return ObjectType.MEGA_5; |
| ... | ... | |
| 629 | 632 |
|
| 630 | 633 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 631 | 634 |
|
| 632 |
public int getObjectName(int numLayers) |
|
| 635 |
public int getObjectName(int[] numLayers)
|
|
| 633 | 636 |
{
|
| 634 |
if( numLayers==3 ) return R.string.minx3; |
|
| 635 |
if( numLayers==5 ) return R.string.minx5; |
|
| 637 |
int numL = numLayers[0]; |
|
| 638 |
|
|
| 639 |
if( numL==3 ) return R.string.minx3; |
|
| 640 |
if( numL==5 ) return R.string.minx5; |
|
| 636 | 641 |
|
| 637 | 642 |
return 0; |
| 638 | 643 |
} |
| 639 | 644 |
|
| 640 | 645 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 641 | 646 |
|
| 642 |
public int getInventor(int numLayers) |
|
| 647 |
public int getInventor(int[] numLayers)
|
|
| 643 | 648 |
{
|
| 644 |
if( numLayers==3 ) return R.string.minx3_inventor; |
|
| 645 |
if( numLayers==5 ) return R.string.minx5_inventor; |
|
| 649 |
int numL = numLayers[0]; |
|
| 650 |
|
|
| 651 |
if( numL==3 ) return R.string.minx3_inventor; |
|
| 652 |
if( numL==5 ) return R.string.minx5_inventor; |
|
| 646 | 653 |
|
| 647 | 654 |
return 0; |
| 648 | 655 |
} |
| 649 | 656 |
|
| 650 | 657 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 651 | 658 |
|
| 652 |
public int getComplexity(int numLayers) |
|
| 659 |
public int getComplexity(int[] numLayers)
|
|
| 653 | 660 |
{
|
| 654 |
if( numLayers==3 ) return 4; |
|
| 661 |
int numL = numLayers[0]; |
|
| 662 |
|
|
| 663 |
if( numL==3 ) return 7; |
|
| 664 |
if( numL==5 ) return 9; |
|
| 655 | 665 |
|
| 656 |
return 5;
|
|
| 666 |
return 9;
|
|
| 657 | 667 |
} |
| 658 | 668 |
} |
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!