Revision caccea6e
Added by Leszek Koltunski over 2 years ago
src/main/java/org/distorted/objects/TwistyCube.java | ||
---|---|---|
23 | 23 |
|
24 | 24 |
import org.distorted.helpers.ObjectShape; |
25 | 25 |
import org.distorted.helpers.ObjectSticker; |
26 |
import org.distorted.helpers.ScrambleStateGraph; |
|
26 | 27 |
import org.distorted.library.main.DistortedEffects; |
27 | 28 |
import org.distorted.library.main.DistortedTexture; |
28 | 29 |
import org.distorted.library.mesh.MeshSquare; |
... | ... | |
128 | 129 |
mStickers[0] = new ObjectSticker(STICKERS[0],null,radii,stroke ); |
129 | 130 |
} |
130 | 131 |
|
132 |
private int mCurrState; |
|
133 |
private int mIndexExcluded; |
|
134 |
private final ScrambleStateGraph[] mStates; |
|
135 |
|
|
131 | 136 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
132 | 137 |
|
133 | 138 |
TwistyCube(int size, Static4D quat, DistortedTexture texture, |
134 | 139 |
MeshSquare mesh, DistortedEffects effects, int[][] moves, Resources res, int scrWidth) |
135 | 140 |
{ |
136 | 141 |
super(size, size, quat, texture, mesh, effects, moves, ObjectList.CUBE, res, scrWidth); |
142 |
|
|
143 |
int[][] m = new int[16][]; |
|
144 |
for(int i=1; i<16; i++) m[i] = createEdges(size,i); |
|
145 |
|
|
146 |
mStates = new ScrambleStateGraph[] // built so that all 3 axes must be present in every 4 consecutive moves |
|
147 |
{ |
|
148 |
new ScrambleStateGraph( new int[][] { m[ 1], m[ 2], m[ 3] } ), // 0 |
|
149 |
new ScrambleStateGraph( new int[][] { null, m[ 4], m[ 5] } ), // x |
|
150 |
new ScrambleStateGraph( new int[][] { m[ 6], null, m[ 7] } ), // y |
|
151 |
new ScrambleStateGraph( new int[][] { m[ 8], m[ 8], null } ), // z |
|
152 |
new ScrambleStateGraph( new int[][] { m[10], null, m[ 7] } ), // xy |
|
153 |
new ScrambleStateGraph( new int[][] { m[11], m[ 9], null } ), // xz |
|
154 |
new ScrambleStateGraph( new int[][] { null, m[12], m[ 5] } ), // yx |
|
155 |
new ScrambleStateGraph( new int[][] { m[ 8], m[13], null } ), // yz |
|
156 |
new ScrambleStateGraph( new int[][] { null, m[ 4], m[14] } ), // zx |
|
157 |
new ScrambleStateGraph( new int[][] { m[ 6], null, m[15] } ), // zy |
|
158 |
new ScrambleStateGraph( new int[][] { null, null, m[ 5] } ), // xyx |
|
159 |
new ScrambleStateGraph( new int[][] { null, m[ 4], null } ), // xzx |
|
160 |
new ScrambleStateGraph( new int[][] { null, null, m[ 7] } ), // yxy |
|
161 |
new ScrambleStateGraph( new int[][] { m[ 6], null, null } ), // yzy |
|
162 |
new ScrambleStateGraph( new int[][] { null, m[ 9], null } ), // zxz |
|
163 |
new ScrambleStateGraph( new int[][] { m[ 8], null, null } ), // zyz |
|
164 |
}; |
|
165 |
} |
|
166 |
|
|
167 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
168 |
|
|
169 |
private int[] createEdges(int size, int vertex) |
|
170 |
{ |
|
171 |
int[] ret = new int[9*size]; |
|
172 |
|
|
173 |
for(int l=0; l<size; l++) |
|
174 |
{ |
|
175 |
ret[9*l ] = l; |
|
176 |
ret[9*l+1] =-1; |
|
177 |
ret[9*l+2] = vertex; |
|
178 |
ret[9*l+3] = l; |
|
179 |
ret[9*l+4] = 1; |
|
180 |
ret[9*l+5] = vertex; |
|
181 |
ret[9*l+6] = l; |
|
182 |
ret[9*l+7] = 2; |
|
183 |
ret[9*l+8] = vertex; |
|
184 |
} |
|
185 |
|
|
186 |
return ret; |
|
137 | 187 |
} |
138 | 188 |
|
139 | 189 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
322 | 372 |
|
323 | 373 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
324 | 374 |
|
325 |
public void randomizeNewScramble(int[][] scramble, Random rnd, int curr, int total) |
|
375 |
public void randomizeNewScramble(int[][] scramble, Random rnd, int curr, int totalScrambles)
|
|
326 | 376 |
{ |
327 | 377 |
if( curr==0 ) |
328 | 378 |
{ |
329 |
scramble[curr][0] = rnd.nextInt(NUM_AXIS); |
|
330 |
} |
|
331 |
else |
|
332 |
{ |
|
333 |
int newVector = rnd.nextInt(NUM_AXIS-1); |
|
334 |
scramble[curr][0] = (newVector>=scramble[curr-1][0] ? newVector+1 : newVector); |
|
335 |
|
|
336 |
// All three axis must be present among every four consecutive rotations. |
|
337 |
// Otherwise in case of odd-sized cubes we can get four consecutive rotations |
|
338 |
// that collapse to a NOP |
|
339 |
// (X,midLayer,180)->(Y,midLayer,180)->(X,midLayer,180)->(Y,midLayer,180) = NOP |
|
340 |
if( curr>=3 && scramble[curr-1][0]==scramble[curr-3][0] ) |
|
341 |
{ |
|
342 |
for( int ax=0; ax<NUM_AXIS; ax++) |
|
343 |
{ |
|
344 |
if( scramble[curr-1][0]!=ax && scramble[curr-2][0]!=ax ) |
|
345 |
{ |
|
346 |
scramble[curr][0] = ax; |
|
347 |
break; |
|
348 |
} |
|
349 |
} |
|
350 |
} |
|
379 |
mCurrState = 0; |
|
380 |
mIndexExcluded =-1; |
|
351 | 381 |
} |
352 | 382 |
|
353 |
float rowFloat = rnd.nextFloat(); |
|
354 |
int numLayers = getNumLayers(); |
|
383 |
int total = mStates[mCurrState].getTotal(mIndexExcluded); |
|
384 |
int random= rnd.nextInt(total); |
|
385 |
int[] info= mStates[mCurrState].getInfo(random,mIndexExcluded); |
|
355 | 386 |
|
356 |
for(int row=0; row<numLayers; row++) |
|
357 |
{ |
|
358 |
if( rowFloat*numLayers <= row+1 ) |
|
359 |
{ |
|
360 |
scramble[curr][1] = row; |
|
361 |
break; |
|
362 |
} |
|
363 |
} |
|
387 |
scramble[curr][0] = info[0]; |
|
388 |
scramble[curr][1] = info[1]; |
|
389 |
scramble[curr][2] = info[2]; |
|
364 | 390 |
|
365 |
switch( rnd.nextInt(4) ) |
|
366 |
{ |
|
367 |
case 0: scramble[curr][2] = -2; break; |
|
368 |
case 1: scramble[curr][2] = -1; break; |
|
369 |
case 2: scramble[curr][2] = 1; break; |
|
370 |
case 3: scramble[curr][2] = 2; break; |
|
371 |
} |
|
391 |
mCurrState = info[3]; |
|
392 |
mIndexExcluded = info[0]; |
|
372 | 393 |
} |
373 | 394 |
|
374 | 395 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
Also available in: Unified diff
Convert the Cubes of all sizes to the new, unified scrambling method.