Revision e649d99a
Added by Leszek Koltunski over 1 year ago
| src/main/java/org/distorted/objectlib/objects/TwistyPyraminx.java | ||
|---|---|---|
| 51 | 51 |
} |
| 52 | 52 |
|
| 53 | 53 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 54 |
// edge[i] is the state after moving layer i (0 is the largest) |
|
| 54 | 55 |
|
| 55 | 56 |
public int[][] getScrambleEdges() |
| 56 | 57 |
{
|
| 57 | 58 |
if( mEdges==null ) |
| 58 | 59 |
{
|
| 59 |
int numLayers = getNumLayers()[0]; |
|
| 60 |
mEdges = new int[numLayers][]; |
|
| 61 |
for(int i=0; i<numLayers-1; i++) mEdges[i] = generateEdge(numLayers-1-i,numLayers); |
|
| 62 |
mEdges[numLayers-1] = generateEdge(numLayers-2,numLayers); |
|
| 60 |
int nL = getNumLayers()[0]; |
|
| 61 |
mEdges = new int[nL][]; |
|
| 62 |
|
|
| 63 |
for(int i=0; i<nL; i++) |
|
| 64 |
{
|
|
| 65 |
int numEnabledMoves = 2*(nL-i); |
|
| 66 |
mEdges[i] = new int[4*2*numEnabledMoves]; |
|
| 67 |
|
|
| 68 |
int index = 0; |
|
| 69 |
int startMove= 0; |
|
| 70 |
int offset = (i==nL-1 ? 2:0); // if the last move was a tip, the only possible |
|
| 71 |
// next move is the second-to-largest layer. |
|
| 72 |
fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves); |
|
| 73 |
index += (2*numEnabledMoves); |
|
| 74 |
startMove += (2*nL); |
|
| 75 |
fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves); |
|
| 76 |
index += (2*numEnabledMoves); |
|
| 77 |
startMove += (2*nL); |
|
| 78 |
fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves); |
|
| 79 |
index += (2*numEnabledMoves); |
|
| 80 |
startMove += (2*nL); |
|
| 81 |
fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves); |
|
| 82 |
} |
|
| 63 | 83 |
} |
| 64 | 84 |
|
| 65 | 85 |
return mEdges; |
| ... | ... | |
| 67 | 87 |
|
| 68 | 88 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 69 | 89 |
|
| 70 |
private int[] generateEdge(int end, int numLayers)
|
|
| 90 |
private void fillEdge(int[] edge, int index, int move, int offset, int num)
|
|
| 71 | 91 |
{
|
| 72 |
int[] ret = new int[8*end]; |
|
| 73 |
|
|
| 74 |
for(int i=0; i<end; i++) |
|
| 92 |
for(int i=0; i<num; i++) |
|
| 75 | 93 |
{
|
| 76 |
int s = ((i/2)%numLayers); |
|
| 77 |
|
|
| 78 |
ret[ 2*i ] = i; |
|
| 79 |
ret[ 2*i+1] = s; |
|
| 80 |
ret[ end+2*i ] = i; |
|
| 81 |
ret[ end+2*i+1] = s; |
|
| 82 |
ret[2*end+2*i ] = i; |
|
| 83 |
ret[2*end+2*i+1] = s; |
|
| 84 |
ret[3*end+2*i ] = i; |
|
| 85 |
ret[3*end+2*i+1] = s; |
|
| 94 |
edge[index+2*i ] = (move+offset); |
|
| 95 |
edge[index+2*i+1] = (i+offset)/2; |
|
| 96 |
move++; |
|
| 86 | 97 |
} |
| 87 |
|
|
| 88 |
return ret; |
|
| 89 | 98 |
} |
| 90 | 99 |
|
| 91 | 100 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
Also available in: Unified diff
Correct scramble tables for the Pyraminxes.