Revision af0de0af
Added by Leszek Koltunski over 2 years ago
src/main/java/org/distorted/objects/TwistyMinx.java | ||
---|---|---|
21 | 21 |
|
22 | 22 |
import android.content.res.Resources; |
23 | 23 |
|
24 |
import org.distorted.helpers.ObjectSticker; |
|
24 | 25 |
import org.distorted.helpers.ScrambleState; |
25 | 26 |
import org.distorted.library.main.DistortedEffects; |
26 | 27 |
import org.distorted.library.main.DistortedTexture; |
... | ... | |
60 | 61 |
new Static3D( SIN54/LEN, 0 , -C2/LEN ) |
61 | 62 |
}; |
62 | 63 |
|
63 |
private static final int[] BASIC_ANGLE = new int[] { 5,5,5,5,5,5 }; |
|
64 |
|
|
65 | 64 |
static final int MINX_LGREEN = 0xff53aa00; |
66 | 65 |
static final int MINX_PINK = 0xfffd7ab7; |
67 | 66 |
static final int MINX_SANDY = 0xffefd48b; |
... | ... | |
82 | 81 |
MINX_DBLUE , MINX_DYELLOW, MINX_WHITE , MINX_GREY |
83 | 82 |
}; |
84 | 83 |
|
85 |
private static final int[] mFaceMap = new int[] {8,10,3,7,1,11,9,2,4,0,5,6}; |
|
84 |
private int mCurrState; |
|
85 |
private int mIndexExcluded; |
|
86 |
private ScrambleState[] mStates; |
|
87 |
private int[][] mScrambleTable; |
|
88 |
private int[] mNumOccurences; |
|
89 |
private int[] mBasicAngle; |
|
90 |
private int[] mFaceMap; |
|
91 |
Static4D[] mQuats; |
|
92 |
float[][] mCenterCoords; |
|
93 |
float[][] mCorners; |
|
94 |
int[][] mCornerFaceMap; |
|
95 |
int[] mQuatEdgeIndices; |
|
96 |
int[] mQuatCornerIndices; |
|
97 |
int[][] mEdgeMap; |
|
98 |
int[][] mCenterMap; |
|
99 |
Static4D[] mBasicCornerV, mCurrCornerV; |
|
100 |
ObjectSticker[] mStickers; |
|
86 | 101 |
|
87 |
// All 60 legal rotation quats of a Minx |
|
88 |
static final Static4D[] QUATS = new Static4D[] |
|
89 |
{ |
|
90 |
new Static4D( 0.0f, 0.0f, 0.0f, 1.0f ), //0 |
|
91 |
new Static4D( 1.0f, 0.0f, 0.0f, 0.0f ), |
|
92 |
new Static4D( 0.0f, 1.0f, 0.0f, 0.0f ), |
|
93 |
new Static4D( 0.0f, 0.0f, 1.0f, 0.0f ), |
|
94 |
|
|
95 |
new Static4D( 0.5f, 0.5f, 0.5f, 0.5f ), //4 |
|
96 |
new Static4D( 0.5f, 0.5f, -0.5f, 0.5f ), |
|
97 |
new Static4D( 0.5f, -0.5f, 0.5f, 0.5f ), |
|
98 |
new Static4D( 0.5f, -0.5f, -0.5f, 0.5f ), |
|
99 |
new Static4D( -0.5f, 0.5f, 0.5f, 0.5f ), |
|
100 |
new Static4D( -0.5f, 0.5f, -0.5f, 0.5f ), |
|
101 |
new Static4D( -0.5f, -0.5f, 0.5f, 0.5f ), |
|
102 |
new Static4D( -0.5f, -0.5f, -0.5f, 0.5f ), |
|
103 |
|
|
104 |
new Static4D( 0.5f, SIN54, SIN18, 0.0f ), // 12 |
|
105 |
new Static4D( 0.5f, SIN54,-SIN18, 0.0f ), |
|
106 |
new Static4D( 0.5f,-SIN54, SIN18, 0.0f ), |
|
107 |
new Static4D( 0.5f,-SIN54,-SIN18, 0.0f ), |
|
108 |
new Static4D( SIN18, 0.5f, SIN54, 0.0f ), |
|
109 |
new Static4D( SIN18, 0.5f,-SIN54, 0.0f ), |
|
110 |
new Static4D(-SIN18, 0.5f, SIN54, 0.0f ), |
|
111 |
new Static4D(-SIN18, 0.5f,-SIN54, 0.0f ), |
|
112 |
new Static4D( SIN54, SIN18, 0.5f, 0.0f ), |
|
113 |
new Static4D( SIN54,-SIN18, 0.5f, 0.0f ), |
|
114 |
new Static4D(-SIN54, SIN18, 0.5f, 0.0f ), |
|
115 |
new Static4D(-SIN54,-SIN18, 0.5f, 0.0f ), |
|
116 |
|
|
117 |
new Static4D( 0.0f, SIN18, SIN54, 0.5f ), //24 |
|
118 |
new Static4D( 0.0f, SIN18,-SIN54, 0.5f ), |
|
119 |
new Static4D( 0.0f,-SIN18, SIN54, 0.5f ), |
|
120 |
new Static4D( 0.0f,-SIN18,-SIN54, 0.5f ), |
|
121 |
new Static4D( SIN18, SIN54, 0.0f, 0.5f ), |
|
122 |
new Static4D( SIN18,-SIN54, 0.0f, 0.5f ), |
|
123 |
new Static4D(-SIN18, SIN54, 0.0f, 0.5f ), |
|
124 |
new Static4D(-SIN18,-SIN54, 0.0f, 0.5f ), |
|
125 |
new Static4D( SIN54, 0.0f, SIN18, 0.5f ), |
|
126 |
new Static4D( SIN54, 0.0f,-SIN18, 0.5f ), |
|
127 |
new Static4D(-SIN54, 0.0f, SIN18, 0.5f ), |
|
128 |
new Static4D(-SIN54, 0.0f,-SIN18, 0.5f ), |
|
129 |
|
|
130 |
new Static4D( 0.0f, SIN54, 0.5f, SIN18 ), //36 |
|
131 |
new Static4D( 0.0f, SIN54, -0.5f, SIN18 ), |
|
132 |
new Static4D( 0.0f,-SIN54, 0.5f, SIN18 ), |
|
133 |
new Static4D( 0.0f,-SIN54, -0.5f, SIN18 ), |
|
134 |
new Static4D( 0.5f, 0.0f, SIN54, SIN18 ), |
|
135 |
new Static4D( 0.5f, 0.0f,-SIN54, SIN18 ), |
|
136 |
new Static4D( -0.5f, 0.0f, SIN54, SIN18 ), |
|
137 |
new Static4D( -0.5f, 0.0f,-SIN54, SIN18 ), |
|
138 |
new Static4D( SIN54, 0.5f, 0.0f, SIN18 ), |
|
139 |
new Static4D( SIN54, -0.5f, 0.0f, SIN18 ), |
|
140 |
new Static4D(-SIN54, 0.5f, 0.0f, SIN18 ), |
|
141 |
new Static4D(-SIN54, -0.5f, 0.0f, SIN18 ), |
|
142 |
|
|
143 |
new Static4D( 0.0f, 0.5f, SIN18, SIN54 ), //48 |
|
144 |
new Static4D( 0.0f, 0.5f,-SIN18, SIN54 ), |
|
145 |
new Static4D( 0.0f, -0.5f, SIN18, SIN54 ), |
|
146 |
new Static4D( 0.0f, -0.5f,-SIN18, SIN54 ), |
|
147 |
new Static4D( 0.5f, SIN18, 0.0f, SIN54 ), |
|
148 |
new Static4D( 0.5f,-SIN18, 0.0f, SIN54 ), |
|
149 |
new Static4D( -0.5f, SIN18, 0.0f, SIN54 ), |
|
150 |
new Static4D( -0.5f,-SIN18, 0.0f, SIN54 ), |
|
151 |
new Static4D( SIN18, 0.0f, 0.5f, SIN54 ), |
|
152 |
new Static4D( SIN18, 0.0f, -0.5f, SIN54 ), |
|
153 |
new Static4D(-SIN18, 0.0f, 0.5f, SIN54 ), |
|
154 |
new Static4D(-SIN18, 0.0f, -0.5f, SIN54 ), |
|
155 |
}; |
|
102 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
156 | 103 |
|
157 |
// Coordinates of all 20 corners of a Minx |
|
158 |
static final float[][] CORNERS = new float[][] |
|
159 |
{ |
|
160 |
{ 0.0f, 0.5f, C2}, |
|
161 |
{ 0.0f, 0.5f, -C2}, |
|
162 |
{ 0.0f, -0.5f, C2}, |
|
163 |
{ 0.0f, -0.5f, -C2}, |
|
164 |
{ C2, 0.0f, 0.5f}, |
|
165 |
{ C2, 0.0f, -0.5f}, |
|
166 |
{ -C2, 0.0f, 0.5f}, |
|
167 |
{ -C2, 0.0f, -0.5f}, |
|
168 |
{ 0.5f, C2, 0.0f}, |
|
169 |
{ 0.5f, -C2, 0.0f}, |
|
170 |
{ -0.5f, C2, 0.0f}, |
|
171 |
{ -0.5f, -C2, 0.0f}, |
|
172 |
{ SIN54, SIN54, SIN54}, |
|
173 |
{ SIN54, SIN54,-SIN54}, |
|
174 |
{ SIN54,-SIN54, SIN54}, |
|
175 |
{ SIN54,-SIN54,-SIN54}, |
|
176 |
{-SIN54, SIN54, SIN54}, |
|
177 |
{-SIN54, SIN54,-SIN54}, |
|
178 |
{-SIN54,-SIN54, SIN54}, |
|
179 |
{-SIN54,-SIN54,-SIN54}, |
|
180 |
}; |
|
104 |
TwistyMinx(int numLayers, int realSize, Static4D quat, DistortedTexture texture, MeshSquare mesh, |
|
105 |
DistortedEffects effects, int[][] moves, ObjectList obj, Resources res, int scrWidth) |
|
106 |
{ |
|
107 |
super(numLayers, realSize, quat, texture, mesh, effects, moves, obj, res, scrWidth); |
|
181 | 108 |
|
182 |
static final int[][] mCornerFaceMap = |
|
183 |
{ |
|
184 |
{ 0, 1, 8 }, |
|
185 |
{ 6, 5,10 }, |
|
186 |
{ 1, 0,11 }, |
|
187 |
{ 5, 6, 3 }, |
|
188 |
{ 0, 9, 4 }, |
|
189 |
{ 5, 4, 9 }, |
|
190 |
{ 7, 1, 2 }, |
|
191 |
{ 2, 6, 7 }, |
|
192 |
{ 10, 9, 8 }, |
|
193 |
{ 4, 3,11 }, |
|
194 |
{ 7,10, 8 }, |
|
195 |
{ 3, 2,11 }, |
|
196 |
{ 0, 8, 9 }, |
|
197 |
{ 9,10, 5 }, |
|
198 |
{ 0, 4,11 }, |
|
199 |
{ 4, 5, 3 }, |
|
200 |
{ 1, 7, 8 }, |
|
201 |
{ 7, 6,10 }, |
|
202 |
{ 2, 1,11 }, |
|
203 |
{ 6, 2, 3 }, |
|
204 |
}; |
|
109 |
initializeScrambleStates(numLayers); |
|
110 |
} |
|
205 | 111 |
|
206 |
static final int[] QUAT_EDGE_INDICES = |
|
207 |
{ |
|
208 |
56, 40, 43, 59, 0, 19, 9, 54, 58, 49, |
|
209 |
48, 24, 52, 4, 16, 32, 20, 11, 21, 35 , |
|
210 |
37, 30, 8, 28, 36, 44, 1, 46, 12, 47 |
|
211 |
}; |
|
212 | 112 |
|
113 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
213 | 114 |
|
214 |
static final int[] QUAT_CORNER_INDICES = |
|
215 |
{ |
|
216 |
0, 2, 3, 1, 40, 31, 41, 30, 39, 35, |
|
217 |
36, 34, 56, 32, 43, 21, 48, 28, 42, 23 |
|
218 |
}; |
|
115 |
void initializeCornerV() |
|
116 |
{ |
|
117 |
mBasicCornerV = new Static4D[3]; |
|
118 |
mCurrCornerV = new Static4D[3]; |
|
119 |
|
|
120 |
mBasicCornerV[0] = new Static4D( (SQ5+1)*0.125f, (SQ5-1)*0.125f, -0.250f, 0.0f ); |
|
121 |
mBasicCornerV[1] = new Static4D(-(SQ5+1)*0.125f, (SQ5-1)*0.125f, -0.250f, 0.0f ); |
|
122 |
mBasicCornerV[2] = new Static4D( 0, -0.500f, 0.0f, 0.0f ); |
|
123 |
} |
|
124 |
|
|
125 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
126 |
// the five vertices that form a given face. Order: the same as colors of the faces in TwistyMinx. |
|
127 |
|
|
128 |
void initializeCenterMap() |
|
129 |
{ |
|
130 |
mCenterMap = new int[][] |
|
131 |
{ |
|
132 |
{ 0, 12, 4, 14, 2}, |
|
133 |
{ 0, 2, 18, 6, 16}, |
|
134 |
{ 6, 18, 11, 19, 7}, |
|
135 |
{ 3, 15, 9, 11, 19}, |
|
136 |
{ 4, 5, 15, 9, 14}, |
|
137 |
{ 1, 13, 5, 15, 3}, |
|
138 |
{ 1, 3, 19, 7, 17}, |
|
139 |
{10, 16, 6, 7, 17}, |
|
140 |
{ 0, 12, 8, 10, 16}, |
|
141 |
{ 8, 13, 5, 4, 12}, |
|
142 |
{ 1, 13, 8, 10, 17}, |
|
143 |
{ 2, 14, 9, 11, 18}, |
|
144 |
}; |
|
145 |
} |
|
219 | 146 |
|
220 |
// the quadruple ( corner1, corner2, face1, face2 ) defining an edge. |
|
221 |
// In fact the 2 corners already define it, the faces only provide easy |
|
222 |
// way to get to know the colors. Order: arbitrary. Face1 arbitrarily on |
|
223 |
// the 'left' or right of vector corner1 --> corner2, according to Quat. |
|
224 |
static final int[][] mEdgeMap = |
|
147 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
148 |
// the quadruple ( corner1, corner2, face1, face2 ) defining an edge. |
|
149 |
// In fact the 2 corners already define it, the faces only provide easy |
|
150 |
// way to get to know the colors. Order: arbitrary. Face1 arbitrarily on |
|
151 |
// the 'left' or right of vector corner1 --> corner2, according to Quat. |
|
152 |
|
|
153 |
void initializeEdgeMap() |
|
154 |
{ |
|
155 |
mEdgeMap = new int[][] |
|
225 | 156 |
{ |
226 | 157 |
{ 0, 12, 0, 8}, //0 |
227 | 158 |
{ 12, 4, 0, 9}, |
... | ... | |
254 | 185 |
{ 1, 13, 10, 5}, |
255 | 186 |
{ 3, 15, 5, 3}, |
256 | 187 |
}; |
188 |
} |
|
257 | 189 |
|
258 |
// the five vertices that form a given face. Order: the same as colors |
|
259 |
// of the faces in TwistyMinx. |
|
260 |
static final int[][] mCenterMap = |
|
261 |
{ |
|
262 |
{ 0, 12, 4, 14, 2}, |
|
263 |
{ 0, 2, 18, 6, 16}, |
|
264 |
{ 6, 18, 11, 19, 7}, |
|
265 |
{ 3, 15, 9, 11, 19}, |
|
266 |
{ 4, 5, 15, 9, 14}, |
|
267 |
{ 1, 13, 5, 15, 3}, |
|
268 |
{ 1, 3, 19, 7, 17}, |
|
269 |
{10, 16, 6, 7, 17}, |
|
270 |
{ 0, 12, 8, 10, 16}, |
|
271 |
{ 8, 13, 5, 4, 12}, |
|
272 |
{ 1, 13, 8, 10, 17}, |
|
273 |
{ 2, 14, 9, 11, 18}, |
|
274 |
}; |
|
275 |
|
|
276 |
static final float[][] mCenterCoords = new float[NUM_CENTERS][3]; |
|
190 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
277 | 191 |
|
278 |
static
|
|
192 |
void initializeQuatIndices()
|
|
279 | 193 |
{ |
280 |
for(int center=0; center<NUM_CENTERS; center++)
|
|
194 |
mQuatEdgeIndices = new int[]
|
|
281 | 195 |
{ |
282 |
int[] map = mCenterMap[center]; |
|
196 |
56, 40, 43, 59, 0, 19, 9, 54, 58, 49, |
|
197 |
48, 24, 52, 4, 16, 32, 20, 11, 21, 35, |
|
198 |
37, 30, 8, 28, 36, 44, 1, 46, 12, 47 |
|
199 |
}; |
|
200 |
mQuatCornerIndices = new int[] |
|
201 |
{ |
|
202 |
0, 2, 3, 1, 40, 31, 41, 30, 39, 35, |
|
203 |
36, 34, 56, 32, 43, 21, 48, 28, 42, 23 |
|
204 |
}; |
|
205 |
} |
|
283 | 206 |
|
284 |
float x = CORNERS[map[0]][0] + |
|
285 |
CORNERS[map[1]][0] + |
|
286 |
CORNERS[map[2]][0] + |
|
287 |
CORNERS[map[3]][0] + |
|
288 |
CORNERS[map[4]][0] ; |
|
207 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
289 | 208 |
|
290 |
float y = CORNERS[map[0]][1] + |
|
291 |
CORNERS[map[1]][1] + |
|
292 |
CORNERS[map[2]][1] + |
|
293 |
CORNERS[map[3]][1] + |
|
294 |
CORNERS[map[4]][1] ; |
|
209 |
void initializeCornerFaceMap() |
|
210 |
{ |
|
211 |
mCornerFaceMap = new int[][] |
|
212 |
{ |
|
213 |
{ 0, 1, 8 }, |
|
214 |
{ 6, 5,10 }, |
|
215 |
{ 1, 0,11 }, |
|
216 |
{ 5, 6, 3 }, |
|
217 |
{ 0, 9, 4 }, |
|
218 |
{ 5, 4, 9 }, |
|
219 |
{ 7, 1, 2 }, |
|
220 |
{ 2, 6, 7 }, |
|
221 |
{ 10, 9, 8 }, |
|
222 |
{ 4, 3,11 }, |
|
223 |
{ 7,10, 8 }, |
|
224 |
{ 3, 2,11 }, |
|
225 |
{ 0, 8, 9 }, |
|
226 |
{ 9,10, 5 }, |
|
227 |
{ 0, 4,11 }, |
|
228 |
{ 4, 5, 3 }, |
|
229 |
{ 1, 7, 8 }, |
|
230 |
{ 7, 6,10 }, |
|
231 |
{ 2, 1,11 }, |
|
232 |
{ 6, 2, 3 }, |
|
233 |
}; |
|
234 |
} |
|
295 | 235 |
|
296 |
float z = CORNERS[map[0]][2] + |
|
297 |
CORNERS[map[1]][2] + |
|
298 |
CORNERS[map[2]][2] + |
|
299 |
CORNERS[map[3]][2] + |
|
300 |
CORNERS[map[4]][2] ; |
|
236 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
301 | 237 |
|
302 |
mCenterCoords[center][0] = x/5; |
|
303 |
mCenterCoords[center][1] = y/5; |
|
304 |
mCenterCoords[center][2] = z/5; |
|
305 |
} |
|
238 |
void initializeQuats() |
|
239 |
{ |
|
240 |
mQuats = new Static4D[] |
|
241 |
{ |
|
242 |
new Static4D( 0.0f, 0.0f, 0.0f, 1.0f ), //0 |
|
243 |
new Static4D( 1.0f, 0.0f, 0.0f, 0.0f ), |
|
244 |
new Static4D( 0.0f, 1.0f, 0.0f, 0.0f ), |
|
245 |
new Static4D( 0.0f, 0.0f, 1.0f, 0.0f ), |
|
246 |
|
|
247 |
new Static4D( 0.5f, 0.5f, 0.5f, 0.5f ), //4 |
|
248 |
new Static4D( 0.5f, 0.5f, -0.5f, 0.5f ), |
|
249 |
new Static4D( 0.5f, -0.5f, 0.5f, 0.5f ), |
|
250 |
new Static4D( 0.5f, -0.5f, -0.5f, 0.5f ), |
|
251 |
new Static4D( -0.5f, 0.5f, 0.5f, 0.5f ), |
|
252 |
new Static4D( -0.5f, 0.5f, -0.5f, 0.5f ), |
|
253 |
new Static4D( -0.5f, -0.5f, 0.5f, 0.5f ), |
|
254 |
new Static4D( -0.5f, -0.5f, -0.5f, 0.5f ), |
|
255 |
|
|
256 |
new Static4D( 0.5f, SIN54, SIN18, 0.0f ), // 12 |
|
257 |
new Static4D( 0.5f, SIN54,-SIN18, 0.0f ), |
|
258 |
new Static4D( 0.5f,-SIN54, SIN18, 0.0f ), |
|
259 |
new Static4D( 0.5f,-SIN54,-SIN18, 0.0f ), |
|
260 |
new Static4D( SIN18, 0.5f, SIN54, 0.0f ), |
|
261 |
new Static4D( SIN18, 0.5f,-SIN54, 0.0f ), |
|
262 |
new Static4D(-SIN18, 0.5f, SIN54, 0.0f ), |
|
263 |
new Static4D(-SIN18, 0.5f,-SIN54, 0.0f ), |
|
264 |
new Static4D( SIN54, SIN18, 0.5f, 0.0f ), |
|
265 |
new Static4D( SIN54,-SIN18, 0.5f, 0.0f ), |
|
266 |
new Static4D(-SIN54, SIN18, 0.5f, 0.0f ), |
|
267 |
new Static4D(-SIN54,-SIN18, 0.5f, 0.0f ), |
|
268 |
|
|
269 |
new Static4D( 0.0f, SIN18, SIN54, 0.5f ), //24 |
|
270 |
new Static4D( 0.0f, SIN18,-SIN54, 0.5f ), |
|
271 |
new Static4D( 0.0f,-SIN18, SIN54, 0.5f ), |
|
272 |
new Static4D( 0.0f,-SIN18,-SIN54, 0.5f ), |
|
273 |
new Static4D( SIN18, SIN54, 0.0f, 0.5f ), |
|
274 |
new Static4D( SIN18,-SIN54, 0.0f, 0.5f ), |
|
275 |
new Static4D(-SIN18, SIN54, 0.0f, 0.5f ), |
|
276 |
new Static4D(-SIN18,-SIN54, 0.0f, 0.5f ), |
|
277 |
new Static4D( SIN54, 0.0f, SIN18, 0.5f ), |
|
278 |
new Static4D( SIN54, 0.0f,-SIN18, 0.5f ), |
|
279 |
new Static4D(-SIN54, 0.0f, SIN18, 0.5f ), |
|
280 |
new Static4D(-SIN54, 0.0f,-SIN18, 0.5f ), |
|
281 |
|
|
282 |
new Static4D( 0.0f, SIN54, 0.5f, SIN18 ), //36 |
|
283 |
new Static4D( 0.0f, SIN54, -0.5f, SIN18 ), |
|
284 |
new Static4D( 0.0f,-SIN54, 0.5f, SIN18 ), |
|
285 |
new Static4D( 0.0f,-SIN54, -0.5f, SIN18 ), |
|
286 |
new Static4D( 0.5f, 0.0f, SIN54, SIN18 ), |
|
287 |
new Static4D( 0.5f, 0.0f,-SIN54, SIN18 ), |
|
288 |
new Static4D( -0.5f, 0.0f, SIN54, SIN18 ), |
|
289 |
new Static4D( -0.5f, 0.0f,-SIN54, SIN18 ), |
|
290 |
new Static4D( SIN54, 0.5f, 0.0f, SIN18 ), |
|
291 |
new Static4D( SIN54, -0.5f, 0.0f, SIN18 ), |
|
292 |
new Static4D(-SIN54, 0.5f, 0.0f, SIN18 ), |
|
293 |
new Static4D(-SIN54, -0.5f, 0.0f, SIN18 ), |
|
294 |
|
|
295 |
new Static4D( 0.0f, 0.5f, SIN18, SIN54 ), //48 |
|
296 |
new Static4D( 0.0f, 0.5f,-SIN18, SIN54 ), |
|
297 |
new Static4D( 0.0f, -0.5f, SIN18, SIN54 ), |
|
298 |
new Static4D( 0.0f, -0.5f,-SIN18, SIN54 ), |
|
299 |
new Static4D( 0.5f, SIN18, 0.0f, SIN54 ), |
|
300 |
new Static4D( 0.5f,-SIN18, 0.0f, SIN54 ), |
|
301 |
new Static4D( -0.5f, SIN18, 0.0f, SIN54 ), |
|
302 |
new Static4D( -0.5f,-SIN18, 0.0f, SIN54 ), |
|
303 |
new Static4D( SIN18, 0.0f, 0.5f, SIN54 ), |
|
304 |
new Static4D( SIN18, 0.0f, -0.5f, SIN54 ), |
|
305 |
new Static4D(-SIN18, 0.0f, 0.5f, SIN54 ), |
|
306 |
new Static4D(-SIN18, 0.0f, -0.5f, SIN54 ), |
|
307 |
}; |
|
306 | 308 |
} |
307 | 309 |
|
308 |
static final Static4D[] mBasicCornerV, mCurrCornerV; |
|
310 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
311 |
// Coordinates of all 20 corners of a Minx |
|
309 | 312 |
|
310 |
static
|
|
313 |
void initializeCorners()
|
|
311 | 314 |
{ |
312 |
mBasicCornerV = new Static4D[3]; |
|
313 |
mCurrCornerV = new Static4D[3]; |
|
314 |
|
|
315 |
mBasicCornerV[0] = new Static4D( (SQ5+1)*0.125f, (SQ5-1)*0.125f, -0.250f, 0.0f ); |
|
316 |
mBasicCornerV[1] = new Static4D(-(SQ5+1)*0.125f, (SQ5-1)*0.125f, -0.250f, 0.0f ); |
|
317 |
mBasicCornerV[2] = new Static4D( 0, -0.500f, 0.0f, 0.0f ); |
|
315 |
mCorners = new float[][] |
|
316 |
{ |
|
317 |
{ 0.0f, 0.5f, C2}, |
|
318 |
{ 0.0f, 0.5f, -C2}, |
|
319 |
{ 0.0f, -0.5f, C2}, |
|
320 |
{ 0.0f, -0.5f, -C2}, |
|
321 |
{ C2, 0.0f, 0.5f}, |
|
322 |
{ C2, 0.0f, -0.5f}, |
|
323 |
{ -C2, 0.0f, 0.5f}, |
|
324 |
{ -C2, 0.0f, -0.5f}, |
|
325 |
{ 0.5f, C2, 0.0f}, |
|
326 |
{ 0.5f, -C2, 0.0f}, |
|
327 |
{ -0.5f, C2, 0.0f}, |
|
328 |
{ -0.5f, -C2, 0.0f}, |
|
329 |
{ SIN54, SIN54, SIN54}, |
|
330 |
{ SIN54, SIN54,-SIN54}, |
|
331 |
{ SIN54,-SIN54, SIN54}, |
|
332 |
{ SIN54,-SIN54,-SIN54}, |
|
333 |
{-SIN54, SIN54, SIN54}, |
|
334 |
{-SIN54, SIN54,-SIN54}, |
|
335 |
{-SIN54,-SIN54, SIN54}, |
|
336 |
{-SIN54,-SIN54,-SIN54}, |
|
337 |
}; |
|
318 | 338 |
} |
319 | 339 |
|
320 |
private int mCurrState; |
|
321 |
private int mIndexExcluded; |
|
322 |
private ScrambleState[] mStates; |
|
323 |
private int[][] mScrambleTable; |
|
324 |
private int[] mNumOccurences; |
|
325 |
|
|
326 | 340 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
327 | 341 |
|
328 |
TwistyMinx(int numLayers, int realSize, Static4D quat, DistortedTexture texture, MeshSquare mesh, |
|
329 |
DistortedEffects effects, int[][] moves, ObjectList obj, Resources res, int scrWidth) |
|
342 |
void initializeCenterCoords() |
|
330 | 343 |
{ |
331 |
super(numLayers, realSize, quat, texture, mesh, effects, moves, obj, res, scrWidth); |
|
344 |
if( mCorners==null ) initializeCorners(); |
|
345 |
if( mCenterMap==null ) initializeCenterMap(); |
|
332 | 346 |
|
333 |
initializeScrambleStates(numLayers); |
|
347 |
mCenterCoords = new float[NUM_CENTERS][3]; |
|
348 |
|
|
349 |
for(int center=0; center<NUM_CENTERS; center++) |
|
350 |
{ |
|
351 |
int[] map = mCenterMap[center]; |
|
352 |
|
|
353 |
float x = mCorners[map[0]][0] + |
|
354 |
mCorners[map[1]][0] + |
|
355 |
mCorners[map[2]][0] + |
|
356 |
mCorners[map[3]][0] + |
|
357 |
mCorners[map[4]][0] ; |
|
358 |
|
|
359 |
float y = mCorners[map[0]][1] + |
|
360 |
mCorners[map[1]][1] + |
|
361 |
mCorners[map[2]][1] + |
|
362 |
mCorners[map[3]][1] + |
|
363 |
mCorners[map[4]][1] ; |
|
364 |
|
|
365 |
float z = mCorners[map[0]][2] + |
|
366 |
mCorners[map[1]][2] + |
|
367 |
mCorners[map[2]][2] + |
|
368 |
mCorners[map[3]][2] + |
|
369 |
mCorners[map[4]][2] ; |
|
370 |
|
|
371 |
mCenterCoords[center][0] = x/5; |
|
372 |
mCenterCoords[center][1] = y/5; |
|
373 |
mCenterCoords[center][2] = z/5; |
|
374 |
} |
|
334 | 375 |
} |
335 | 376 |
|
336 | 377 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
463 | 504 |
|
464 | 505 |
int[] getSolvedQuats(int cubit, int numLayers) |
465 | 506 |
{ |
507 |
if( mQuats==null ) initializeQuats(); |
|
508 |
if( mFaceMap==null ) mFaceMap = new int[] {8,10,3,7,1,11,9,2,4,0,5,6}; |
|
466 | 509 |
int status = retCubitSolvedStatus(cubit,numLayers); |
467 |
return status<0 ? null : buildSolvedQuats(MovementMinx.FACE_AXIS[mFaceMap[status]],QUATS);
|
|
510 |
return status<0 ? null : buildSolvedQuats(MovementMinx.FACE_AXIS[mFaceMap[status]],mQuats);
|
|
468 | 511 |
} |
469 | 512 |
|
470 | 513 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
471 | 514 |
|
472 | 515 |
Static4D[] getQuats() |
473 | 516 |
{ |
474 |
return QUATS; |
|
517 |
if( mQuats==null ) initializeQuats(); |
|
518 |
return mQuats; |
|
475 | 519 |
} |
476 | 520 |
|
477 | 521 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
569 | 613 |
|
570 | 614 |
public int[] getBasicAngle() |
571 | 615 |
{ |
572 |
return BASIC_ANGLE; |
|
616 |
if( mBasicAngle ==null ) mBasicAngle = new int[] { 5,5,5,5,5,5 }; |
|
617 |
return mBasicAngle; |
|
573 | 618 |
} |
574 | 619 |
} |
Also available in: Unified diff
Remove statics from the Minx classes.