Revision b2496566
Added by Leszek Koltunski 9 months ago
| src/main/java/org/distorted/objectlib/objects/TwistyRedi.java | ||
|---|---|---|
| 22 | 22 |
import org.distorted.objectlib.main.InitAssets; |
| 23 | 23 |
import org.distorted.objectlib.main.InitData; |
| 24 | 24 |
import org.distorted.objectlib.main.ObjectSignatures; |
| 25 |
import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator; |
|
| 25 | 26 |
import org.distorted.objectlib.touchcontrol.TouchControlHexahedron; |
| 26 | 27 |
import org.distorted.objectlib.main.ObjectType; |
| 27 | 28 |
import org.distorted.objectlib.helpers.ObjectShape; |
| ... | ... | |
| 44 | 45 |
private float[][] mCuts; |
| 45 | 46 |
private float[][] mPosition; |
| 46 | 47 |
private int[] mQuatIndex; |
| 48 |
private boolean[][] mRotatable; |
|
| 47 | 49 |
|
| 48 | 50 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 49 | 51 |
|
| ... | ... | |
| 57 | 59 |
@Override |
| 58 | 60 |
public float[][] returnRotationFactor() |
| 59 | 61 |
{
|
| 60 |
float C = 1.5f;
|
|
| 62 |
float C = 2.0f;
|
|
| 61 | 63 |
int numL = getNumLayers()[0]; |
| 62 | 64 |
float[] f = new float[numL]; |
| 63 | 65 |
for(int i=0; i<numL; i++) f[i] = C; |
| ... | ... | |
| 70 | 72 |
{
|
| 71 | 73 |
if( mEdges==null ) |
| 72 | 74 |
{
|
| 73 |
mEdges = new int[][] |
|
| 75 |
int[] numLayers = getNumLayers(); |
|
| 76 |
|
|
| 77 |
if( numLayers[0]==3 ) |
|
| 74 | 78 |
{
|
| 75 |
{ 0,8,1,8, 4,1,5,1, 6,7,7,7, 10,2,11,2, 12,6,13,6, 16,3,17,3, 18,5,19,5, 22,4,23,4 }, // 0
|
|
| 76 |
{ 10,2,11,2, 16,3,17,3, 18,5,19,5 }, // 1
|
|
| 77 |
{ 4,1,5,1, 12,6,13,6, 22,4,23,4 }, // 2
|
|
| 78 |
{ 4,1,5,1, 6,7,7,7, 22,4,23,4 }, // 3
|
|
| 79 |
{ 0,8,1,8, 10,2,11,2, 16,3,17,3 }, // 4
|
|
| 80 |
{ 4,1,5,1, 6,7,7,7, 12,6,13,6 }, // 5
|
|
| 81 |
{ 0,8,1,8, 10,2,11,2, 18,5,19,5 }, // 6
|
|
| 82 |
{ 0,8,1,8, 16,3,17,3, 18,5,19,5 }, // 7
|
|
| 83 |
{ 6,7,7,7, 12,6,13,6, 22,4,23,4 }, // 8
|
|
| 84 |
}; |
|
| 79 |
mEdges = new int[][] |
|
| 80 |
{
|
|
| 81 |
{ 0,8,1,8, 4,1,5,1, 6,7,7,7, 10,2,11,2, 12,6,13,6, 16,3,17,3, 18,5,19,5, 22,4,23,4 }, // 0
|
|
| 82 |
{ 10,2,11,2, 16,3,17,3, 18,5,19,5 }, // 1
|
|
| 83 |
{ 4,1,5,1, 12,6,13,6, 22,4,23,4 }, // 2
|
|
| 84 |
{ 4,1,5,1, 6,7,7,7, 22,4,23,4 }, // 3
|
|
| 85 |
{ 0,8,1,8, 10,2,11,2, 16,3,17,3 }, // 4
|
|
| 86 |
{ 4,1,5,1, 6,7,7,7, 12,6,13,6 }, // 5
|
|
| 87 |
{ 0,8,1,8, 10,2,11,2, 18,5,19,5 }, // 6
|
|
| 88 |
{ 0,8,1,8, 16,3,17,3, 18,5,19,5 }, // 7
|
|
| 89 |
{ 6,7,7,7, 12,6,13,6, 22,4,23,4 }, // 8
|
|
| 90 |
}; |
|
| 91 |
} |
|
| 92 |
else |
|
| 93 |
{
|
|
| 94 |
if( mRotatable==null ) mRotatable = createRotatable(); |
|
| 95 |
mEdges = ScrambleEdgeGenerator.getScrambleEdgesSingle(mBasicAngle, mRotatable); |
|
| 96 |
} |
|
| 85 | 97 |
} |
| 86 | 98 |
|
| 87 | 99 |
return mEdges; |
| 88 | 100 |
} |
| 89 | 101 |
|
| 102 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 103 |
|
|
| 104 |
@Override |
|
| 105 |
public int[][] getScrambleAlgorithms() |
|
| 106 |
{
|
|
| 107 |
if( mRotatable==null ) mRotatable = createRotatable(); |
|
| 108 |
return ScrambleEdgeGenerator.getScramblingAlgorithms(mBasicAngle, mRotatable); |
|
| 109 |
} |
|
| 110 |
|
|
| 90 | 111 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 91 | 112 |
|
| 92 | 113 |
public float[][] getCuts(int[] numLayers) |
| ... | ... | |
| 99 | 120 |
float[] c3 = new float[] {-C3,C3};
|
| 100 | 121 |
mCuts = new float[][] { c3,c3,c3,c3 };
|
| 101 | 122 |
break; |
| 102 |
case 5: float A5 = 25*SQ3/16;
|
|
| 103 |
float B5 = 25*SQ3/12;
|
|
| 123 |
case 5: float A5 = 5*SQ3/3;
|
|
| 124 |
float B5 = 3*SQ3/3;
|
|
| 104 | 125 |
float[] c5 = new float[] {-A5,-B5, B5, A5};
|
| 105 | 126 |
mCuts = new float[][] { c5,c5,c5,c5 };
|
| 106 | 127 |
break; |
| ... | ... | |
| 113 | 134 |
|
| 114 | 135 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 115 | 136 |
|
| 116 |
public boolean[][] getLayerRotatable(int[] numLayers)
|
|
| 137 |
private boolean[][] createRotatable()
|
|
| 117 | 138 |
{
|
| 118 |
switch( numLayers[0] ) |
|
| 139 |
int numL = getNumLayers()[0]; |
|
| 140 |
|
|
| 141 |
switch( numL ) |
|
| 119 | 142 |
{
|
| 120 | 143 |
case 3: boolean[] t3 = new boolean[] {true,false,true};
|
| 121 | 144 |
return new boolean[][] { t3,t3,t3,t3 };
|
| ... | ... | |
| 125 | 148 |
return null; |
| 126 | 149 |
} |
| 127 | 150 |
|
| 151 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 152 |
|
|
| 153 |
public boolean[][] getLayerRotatable(int[] numLayers) |
|
| 154 |
{
|
|
| 155 |
if( mRotatable==null ) mRotatable = createRotatable(); |
|
| 156 |
return mRotatable; |
|
| 157 |
} |
|
| 158 |
|
|
| 128 | 159 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 129 | 160 |
|
| 130 | 161 |
public int getTouchControlType() |
| ... | ... | |
| 282 | 313 |
|
| 283 | 314 |
public Static4D getCubitQuats(int cubit, int[] numLayers) |
| 284 | 315 |
{
|
| 285 |
if( cubit<8 ) |
|
| 286 |
switch(cubit) |
|
| 287 |
{
|
|
| 288 |
case 0: return mObjectQuats[0]; // unit quat |
|
| 289 |
case 1: return new Static4D( SQ2/2,0,0,SQ2/2); // 90 along X |
|
| 290 |
case 2: return new Static4D(-SQ2/2,0,0,SQ2/2); // -90 along X |
|
| 291 |
case 3: return mObjectQuats[9]; // 180 along X |
|
| 292 |
case 4: return new Static4D(0, SQ2/2,0,SQ2/2); // 90 along Y |
|
| 293 |
case 5: return mObjectQuats[11]; // 180 along Y |
|
| 294 |
case 6: return mObjectQuats[10]; // 180 along Z |
|
| 295 |
case 7: return new Static4D(SQ2/2,0,-SQ2/2,0); // 180 along (SQ2/2,0,-SQ2/2) |
|
| 296 |
} |
|
| 316 |
if( mQuatIndex==null ) mQuatIndex = new int[] { 0,2,10,8,1,4,6,7,11,5,9,3, 0,11,2,3,4,1 };
|
|
| 297 | 317 |
|
| 298 |
if( mQuatIndex==null )
|
|
| 318 |
switch(cubit)
|
|
| 299 | 319 |
{
|
| 300 |
mQuatIndex = new int[] |
|
| 301 |
{
|
|
| 302 |
0,2,10,8,1,4,6,7,11,5,9,3, |
|
| 303 |
0,11,2,3,4,1 |
|
| 304 |
}; |
|
| 320 |
case 0: return mObjectQuats[0]; // unit quat |
|
| 321 |
case 1: return new Static4D( SQ2/2,0,0,SQ2/2); // 90 along X |
|
| 322 |
case 2: return new Static4D(-SQ2/2,0,0,SQ2/2); // -90 along X |
|
| 323 |
case 3: return mObjectQuats[9]; // 180 along X |
|
| 324 |
case 4: return new Static4D(0, SQ2/2,0,SQ2/2); // 90 along Y |
|
| 325 |
case 5: return mObjectQuats[11]; // 180 along Y |
|
| 326 |
case 6: return mObjectQuats[10]; // 180 along Z |
|
| 327 |
case 7: return new Static4D(SQ2/2,0,-SQ2/2,0); // 180 along (SQ2/2,0,-SQ2/2) |
|
| 328 |
default: int index = numLayers[0]==3 ? (cubit-8) : (cubit<32 ? (cubit-8)/2 : (cubit-32)/4 + 12); |
|
| 329 |
return mObjectQuats[mQuatIndex[index]]; |
|
| 305 | 330 |
} |
| 306 |
|
|
| 307 |
int index = numLayers[0]==3 ? (cubit-8) : (cubit<32 ? (cubit-8)/2 : (cubit-32)/4 + 12); |
|
| 308 |
return mObjectQuats[mQuatIndex[index]]; |
|
| 309 | 331 |
} |
| 310 | 332 |
|
| 311 | 333 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 511 | 533 |
|
| 512 | 534 |
public int[][] getBasicAngles() |
| 513 | 535 |
{
|
| 514 |
if( mBasicAngle ==null )
|
|
| 536 |
if( mBasicAngle==null ) |
|
| 515 | 537 |
{
|
| 516 | 538 |
int num = getNumLayers()[0]; |
| 517 | 539 |
int[] tmp = new int[num]; |
Also available in: Unified diff
Finish Mosaic Cube.