Revision 8c8a9fb9
Added by Leszek Koltunski about 1 year ago
src/main/java/org/distorted/solvers/SolverCuboid323.java | ||
---|---|---|
16 | 16 |
import org.distorted.objectlib.main.ObjectSignatures; |
17 | 17 |
import org.distorted.objectlib.main.TwistyObject; |
18 | 18 |
import org.distorted.objectlib.tablebases.ImplementedTablebasesList; |
19 |
import org.distorted.objectlib.tablebases.TablebaseHelpers; |
|
20 | 19 |
import org.distorted.objectlib.tablebases.TablebasesAbstract; |
21 | 20 |
|
22 | 21 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
32 | 31 |
TablebasesAbstract mSolver; |
33 | 32 |
private final int[] mFaceColors; |
34 | 33 |
private int mErrorColor1, mErrorColor2, mErrorColor3; |
34 |
private boolean mUpper; |
|
35 | 35 |
|
36 | 36 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
37 | 37 |
|
... | ... | |
150 | 150 |
return 0; |
151 | 151 |
} |
152 | 152 |
|
153 |
//////////////////////////////////////////////////////////////////////////////////////// |
|
153 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
154 | 154 |
|
155 |
private int computeFaceColors(int[][] corners, int[][] edges, int[] centers)
|
|
155 |
private int[] correctEdgePerm(int[] perm)
|
|
156 | 156 |
{ |
157 |
mFaceColors[2] = centers[0]; |
|
158 |
mFaceColors[3] = centers[1]; |
|
157 |
int[] ret = new int[3]; |
|
158 |
|
|
159 |
ret[0] = perm[0]; |
|
160 |
ret[1] = perm[2]; |
|
161 |
ret[2] = perm[3]; |
|
162 |
|
|
163 |
if( ret[0]>1 ) ret[0]--; |
|
164 |
if( ret[1]>1 ) ret[1]--; |
|
165 |
if( ret[2]>1 ) ret[2]--; |
|
159 | 166 |
|
160 |
if( edges[1][1]==mFaceColors[2] ) mFaceColors[4] = edges[1][0];
|
|
161 |
else if( edges[1][1]==mFaceColors[2] ) mFaceColors[4] = edges[1][0];
|
|
167 |
return ret;
|
|
168 |
}
|
|
162 | 169 |
|
163 |
if( edges[0][0]==mFaceColors[1] ) mFaceColors[5] = edges[0][1]; |
|
164 |
else if( edges[2][0]==mFaceColors[1] ) mFaceColors[5] = edges[2][1]; |
|
165 |
else if( edges[3][0]==mFaceColors[1] ) mFaceColors[5] = edges[3][1]; |
|
166 |
else return ERROR_EDGE_TWISTED; |
|
170 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
167 | 171 |
|
168 |
if( edges[0][1]==mFaceColors[4] ) mFaceColors[0] = edges[0][0]; |
|
169 |
else if( edges[2][1]==mFaceColors[4] ) mFaceColors[0] = edges[2][0]; |
|
170 |
else if( edges[3][1]==mFaceColors[4] ) mFaceColors[0] = edges[3][0]; |
|
171 |
else return ERROR_EDGE_TWISTED; |
|
172 |
public SolverCuboid323(OperatingSystemInterface os, Resources res, TwistyObject object) |
|
173 |
{ |
|
174 |
super(os,res,object); |
|
175 |
mFaceColors = new int[6]; |
|
176 |
} |
|
172 | 177 |
|
173 |
boolean found2 = false; |
|
174 |
boolean found3 = false; |
|
178 |
//////////////////////////////////////////////////////////////////////////////////////// |
|
175 | 179 |
|
176 |
for(int c=0; c<8; c++) |
|
180 |
private int findCorner(int[][] corners, int c1, int c2) |
|
181 |
{ |
|
182 |
for(int i=0; i<8; i++) |
|
177 | 183 |
{ |
178 |
if( !found3 && corners[c][1]==mFaceColors[4] && corners[c][2]==mFaceColors[1] ) |
|
184 |
int[] c = corners[i]; |
|
185 |
|
|
186 |
if( c[0]==c1 && c[1]==c2 ) return c[2]; |
|
187 |
if( c[1]==c1 && c[2]==c2 ) return c[0]; |
|
188 |
if( c[2]==c1 && c[0]==c2 ) return c[1]; |
|
189 |
} |
|
190 |
|
|
191 |
return ERROR_CORNERS_CANNOT; |
|
192 |
} |
|
193 |
|
|
194 |
//////////////////////////////////////////////////////////////////////////////////////// |
|
195 |
|
|
196 |
private int missingColor() |
|
197 |
{ |
|
198 |
boolean[] present = new boolean[6]; |
|
199 |
for(int i=0; i<5; i++) present[mFaceColors[i]] = true; |
|
200 |
|
|
201 |
int indexFalse = -1; |
|
202 |
|
|
203 |
for(int i=0; i<6; i++) |
|
204 |
if( !present[i] ) |
|
179 | 205 |
{ |
180 |
found3=true;
|
|
181 |
mFaceColors[3] = corners[c][0];
|
|
206 |
if( indexFalse<0 ) indexFalse=i;
|
|
207 |
else return ERROR_CORNERS_CANNOT;
|
|
182 | 208 |
} |
183 |
if( !found2 && corners[c][1]==mFaceColors[1] && corners[c][2]==mFaceColors[4] ) |
|
209 |
|
|
210 |
return indexFalse; |
|
211 |
} |
|
212 |
|
|
213 |
//////////////////////////////////////////////////////////////////////////////////////// |
|
214 |
|
|
215 |
private int edgePresent(int[][] edges, int f0, int f1) |
|
216 |
{ |
|
217 |
int c0 = mFaceColors[f0]; |
|
218 |
int c1 = mFaceColors[f1]; |
|
219 |
|
|
220 |
for(int[] edge : edges) |
|
221 |
{ |
|
222 |
if( edge[0]==c0 && edge[1]==c1 ) |
|
223 |
return 0; |
|
224 |
if( edge[0]==c1 && edge[1]==c0 ) |
|
184 | 225 |
{ |
185 |
found2=true; |
|
186 |
mFaceColors[2] = corners[c][0]; |
|
226 |
mErrorColor1 = c0; |
|
227 |
mErrorColor2 = c1; |
|
228 |
return ERROR_EDGE_TWISTED; |
|
187 | 229 |
} |
188 | 230 |
} |
189 | 231 |
|
190 |
if( !found2 || !found3 ) return ERROR_CORNERS_CANNOT; |
|
232 |
mErrorColor1 = c0; |
|
233 |
mErrorColor2 = c1; |
|
234 |
return ERROR_EDGE_MISSING; |
|
235 |
} |
|
191 | 236 |
|
192 |
for(int i=0; i<6; i++) |
|
193 |
for(int j=i+1; j<6; j++) |
|
194 |
if( mFaceColors[i]==mFaceColors[j] ) return ERROR_CORNERS_CANNOT; |
|
237 |
//////////////////////////////////////////////////////////////////////////////////////// |
|
195 | 238 |
|
196 |
return 0; |
|
239 |
private int cornerPresent(int[][] corners, int f0, int f1, int f2) |
|
240 |
{ |
|
241 |
int c0 = mFaceColors[f0]; |
|
242 |
int c1 = mFaceColors[f1]; |
|
243 |
int c2 = mFaceColors[f2]; |
|
244 |
|
|
245 |
for(int[] corner : corners ) |
|
246 |
{ |
|
247 |
if( corner[0]==c0 && corner[1]==c1 && corner[2]==c2 ) return 0; |
|
248 |
if( (corner[0]==c1 && corner[1]==c2 && corner[2]==c0 ) || |
|
249 |
(corner[0]==c2 && corner[1]==c0 && corner[2]==c1 ) ) |
|
250 |
{ |
|
251 |
mErrorColor1 = c0; |
|
252 |
mErrorColor2 = c1; |
|
253 |
mErrorColor3 = c2; |
|
254 |
return ERROR_CORNER_TWISTED; |
|
255 |
} |
|
256 |
} |
|
257 |
|
|
258 |
mErrorColor1 = c0; |
|
259 |
mErrorColor2 = c1; |
|
260 |
mErrorColor3 = c2; |
|
261 |
return ERROR_CORNER_MISSING; |
|
197 | 262 |
} |
198 | 263 |
|
199 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
264 |
//////////////////////////////////////////////////////////////////////////////////////// |
|
200 | 265 |
|
201 |
private int[] correctEdgePerm(int[] perm)
|
|
266 |
private int checkAllEdgesPresent(int[][] edges)
|
|
202 | 267 |
{ |
203 |
int[] ret = new int[3]; |
|
268 |
int result; |
|
269 |
|
|
270 |
result = edgePresent(edges,0,2); |
|
271 |
if( result<0 ) return result; |
|
272 |
result = edgePresent(edges,1,2); |
|
273 |
if( result<0 ) return result; |
|
274 |
result = edgePresent(edges,4,2); |
|
275 |
if( result<0 ) return result; |
|
276 |
result = edgePresent(edges,5,2); |
|
277 |
if( result<0 ) return result; |
|
278 |
result = edgePresent(edges,0,3); |
|
279 |
if( result<0 ) return result; |
|
280 |
result = edgePresent(edges,1,3); |
|
281 |
if( result<0 ) return result; |
|
282 |
result = edgePresent(edges,4,3); |
|
283 |
if( result<0 ) return result; |
|
284 |
result = edgePresent(edges,5,3); |
|
285 |
if( result<0 ) return result; |
|
204 | 286 |
|
205 |
ret[0] = perm[0]; |
|
206 |
ret[1] = perm[2]; |
|
207 |
ret[2] = perm[3]; |
|
287 |
return 0; |
|
288 |
} |
|
208 | 289 |
|
209 |
if( ret[0]>1 ) ret[0]--; |
|
210 |
if( ret[1]>1 ) ret[1]--; |
|
211 |
if( ret[2]>1 ) ret[2]--; |
|
290 |
//////////////////////////////////////////////////////////////////////////////////////// |
|
212 | 291 |
|
213 |
return ret; |
|
292 |
private int checkAllCornersPresent(int[][] corners) |
|
293 |
{ |
|
294 |
int result; |
|
295 |
|
|
296 |
result = cornerPresent(corners,0,4,2); |
|
297 |
if( result<0 ) return result; |
|
298 |
result = cornerPresent(corners,5,0,2); |
|
299 |
if( result<0 ) return result; |
|
300 |
result = cornerPresent(corners,1,5,2); |
|
301 |
if( result<0 ) return result; |
|
302 |
result = cornerPresent(corners,4,1,2); |
|
303 |
if( result<0 ) return result; |
|
304 |
result = cornerPresent(corners,4,0,3); |
|
305 |
if( result<0 ) return result; |
|
306 |
result = cornerPresent(corners,0,5,3); |
|
307 |
if( result<0 ) return result; |
|
308 |
result = cornerPresent(corners,5,1,3); |
|
309 |
if( result<0 ) return result; |
|
310 |
result = cornerPresent(corners,1,4,3); |
|
311 |
if( result<0 ) return result; |
|
312 |
|
|
313 |
return 0; |
|
214 | 314 |
} |
215 | 315 |
|
216 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
316 |
//////////////////////////////////////////////////////////////////////////////////////// |
|
217 | 317 |
|
218 |
public SolverCuboid323(OperatingSystemInterface os, Resources res, TwistyObject object)
|
|
318 |
private int computeFaceColors(int[][] corners, int[][] edges, int[] centers)
|
|
219 | 319 |
{ |
220 |
super(os,res,object); |
|
221 |
mFaceColors = new int[6]; |
|
320 |
mFaceColors[2] = centers[0]; |
|
321 |
mFaceColors[3] = centers[1]; |
|
322 |
|
|
323 |
if( edges[1][1]==mFaceColors[2] ) |
|
324 |
{ |
|
325 |
mUpper = true; |
|
326 |
mFaceColors[4] = edges[1][0]; |
|
327 |
} |
|
328 |
else if( edges[3][1]==mFaceColors[2] ) |
|
329 |
{ |
|
330 |
mUpper = true; |
|
331 |
mFaceColors[4] = edges[3][0]; |
|
332 |
} |
|
333 |
else |
|
334 |
{ |
|
335 |
mUpper = false; |
|
336 |
mFaceColors[4] = edges[3][0]; |
|
337 |
} |
|
338 |
|
|
339 |
mFaceColors[0] = findCorner(corners,mFaceColors[4],mFaceColors[2]); |
|
340 |
if( mFaceColors[0]<0 ) return mFaceColors[0]; |
|
341 |
|
|
342 |
mFaceColors[1] = findCorner(corners,mFaceColors[2],mFaceColors[4]); |
|
343 |
if( mFaceColors[1]<0 ) return mFaceColors[1]; |
|
344 |
|
|
345 |
mFaceColors[5] = missingColor(); |
|
346 |
if( mFaceColors[5]<0 ) return mFaceColors[5]; |
|
347 |
|
|
348 |
return 0; |
|
222 | 349 |
} |
223 | 350 |
|
224 | 351 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
225 | 352 |
|
226 | 353 |
private void getCorners(TwistyObject object, int[][] corners) |
227 | 354 |
{ |
228 |
corners[0][0] = object.getCubitFaceStickerIndex(0,1);
|
|
229 |
corners[0][1] = object.getCubitFaceStickerIndex(0,3);
|
|
230 |
corners[0][2] = object.getCubitFaceStickerIndex(0,5);
|
|
355 |
corners[0][0] = object.getCubitFaceStickerIndex(0,5);
|
|
356 |
corners[0][1] = object.getCubitFaceStickerIndex(0,1);
|
|
357 |
corners[0][2] = object.getCubitFaceStickerIndex(0,3);
|
|
231 | 358 |
|
232 | 359 |
corners[1][0] = object.getCubitFaceStickerIndex(1,3); |
233 |
corners[1][1] = object.getCubitFaceStickerIndex(1,1);
|
|
234 |
corners[1][2] = object.getCubitFaceStickerIndex(1,5);
|
|
360 |
corners[1][1] = object.getCubitFaceStickerIndex(1,5);
|
|
361 |
corners[1][2] = object.getCubitFaceStickerIndex(1,1);
|
|
235 | 362 |
|
236 | 363 |
corners[2][0] = object.getCubitFaceStickerIndex(2,5); |
237 |
corners[2][1] = object.getCubitFaceStickerIndex(2,3);
|
|
238 |
corners[2][2] = object.getCubitFaceStickerIndex(2,1);
|
|
364 |
corners[2][1] = object.getCubitFaceStickerIndex(2,1);
|
|
365 |
corners[2][2] = object.getCubitFaceStickerIndex(2,3);
|
|
239 | 366 |
|
240 |
corners[3][0] = object.getCubitFaceStickerIndex(3,1);
|
|
241 |
corners[3][1] = object.getCubitFaceStickerIndex(3,3);
|
|
242 |
corners[3][2] = object.getCubitFaceStickerIndex(3,5);
|
|
367 |
corners[3][0] = object.getCubitFaceStickerIndex(3,5);
|
|
368 |
corners[3][1] = object.getCubitFaceStickerIndex(3,1);
|
|
369 |
corners[3][2] = object.getCubitFaceStickerIndex(3,3);
|
|
243 | 370 |
|
244 | 371 |
corners[4][0] = object.getCubitFaceStickerIndex(4,1); |
245 |
corners[4][1] = object.getCubitFaceStickerIndex(4,5);
|
|
246 |
corners[4][2] = object.getCubitFaceStickerIndex(4,3);
|
|
372 |
corners[4][1] = object.getCubitFaceStickerIndex(4,3);
|
|
373 |
corners[4][2] = object.getCubitFaceStickerIndex(4,5);
|
|
247 | 374 |
|
248 |
corners[5][0] = object.getCubitFaceStickerIndex(5,1);
|
|
249 |
corners[5][1] = object.getCubitFaceStickerIndex(5,3);
|
|
250 |
corners[5][2] = object.getCubitFaceStickerIndex(5,5);
|
|
375 |
corners[5][0] = object.getCubitFaceStickerIndex(5,5);
|
|
376 |
corners[5][1] = object.getCubitFaceStickerIndex(5,1);
|
|
377 |
corners[5][2] = object.getCubitFaceStickerIndex(5,3);
|
|
251 | 378 |
|
252 |
corners[6][0] = object.getCubitFaceStickerIndex(6,1);
|
|
253 |
corners[6][1] = object.getCubitFaceStickerIndex(6,3);
|
|
254 |
corners[6][2] = object.getCubitFaceStickerIndex(6,5);
|
|
379 |
corners[6][0] = object.getCubitFaceStickerIndex(6,5);
|
|
380 |
corners[6][1] = object.getCubitFaceStickerIndex(6,1);
|
|
381 |
corners[6][2] = object.getCubitFaceStickerIndex(6,3);
|
|
255 | 382 |
|
256 | 383 |
corners[7][0] = object.getCubitFaceStickerIndex(7,1); |
257 |
corners[7][1] = object.getCubitFaceStickerIndex(7,5);
|
|
258 |
corners[7][2] = object.getCubitFaceStickerIndex(7,3);
|
|
384 |
corners[7][1] = object.getCubitFaceStickerIndex(7,3);
|
|
385 |
corners[7][2] = object.getCubitFaceStickerIndex(7,5);
|
|
259 | 386 |
} |
260 | 387 |
|
261 | 388 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
300 | 427 |
getEdges(object,edges); |
301 | 428 |
getCenters(object,centers); |
302 | 429 |
|
430 |
for(int i=0; i<8; i++) android.util.Log.e("D", "corner: "+i+" : "+corners[i][0]+" "+corners[i][1]+" "+corners[i][2]); |
|
431 |
|
|
303 | 432 |
int result0 = computeFaceColors(corners, edges, centers); |
304 | 433 |
if( result0<0 ) return result0; |
434 |
|
|
435 |
int result1 = checkAllEdgesPresent(edges); |
|
436 |
if( result1<0 ) return result1; |
|
437 |
|
|
438 |
int result2 = checkAllCornersPresent(corners); |
|
439 |
if( result2<0 ) return result2; |
|
440 |
|
|
441 |
android.util.Log.e("D", "upper: "+mUpper); |
|
442 |
for(int i=0; i<6; i++) android.util.Log.e("D", "face color: "+mFaceColors[i]); |
|
305 | 443 |
/* |
306 | 444 |
int[] corner_perm = new int[8]; |
307 | 445 |
int result1 = retCornerPermutation(corner_perm,corners); |
... | ... | |
324 | 462 |
|
325 | 463 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
326 | 464 |
|
327 |
private int getColorIndex4(int face)
|
|
465 |
private int getColorIndex4(int color)
|
|
328 | 466 |
{ |
329 |
switch(mFaceColors[face])
|
|
467 |
switch(color)
|
|
330 | 468 |
{ |
331 | 469 |
case 0: return R.string.color_yellow4; |
332 | 470 |
case 1: return R.string.color_white4; |
... | ... | |
341 | 479 |
|
342 | 480 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
343 | 481 |
|
344 |
private int getColorIndex3(int face)
|
|
482 |
private int getColorIndex3(int color)
|
|
345 | 483 |
{ |
346 |
switch(mFaceColors[face])
|
|
484 |
switch(color)
|
|
347 | 485 |
{ |
348 | 486 |
case 0: return R.string.color_yellow3; |
349 | 487 |
case 1: return R.string.color_white3; |
... | ... | |
358 | 496 |
|
359 | 497 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
360 | 498 |
|
361 |
private int getColorIndex6(int face) |
|
499 |
private int getColorIndex5(int color) |
|
500 |
{ |
|
501 |
switch(color) |
|
502 |
{ |
|
503 |
case 0: return R.string.color_yellow5; |
|
504 |
case 1: return R.string.color_white5; |
|
505 |
case 2: return R.string.color_blue5; |
|
506 |
case 3: return R.string.color_green5; |
|
507 |
case 4: return R.string.color_red5; |
|
508 |
case 5: return R.string.color_orange5; |
|
509 |
} |
|
510 |
|
|
511 |
return -1; |
|
512 |
} |
|
513 |
|
|
514 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
515 |
|
|
516 |
private int getColorIndex6(int color) |
|
362 | 517 |
{ |
363 |
switch(mFaceColors[face])
|
|
518 |
switch(color)
|
|
364 | 519 |
{ |
365 | 520 |
case 0: return R.string.color_yellow6; |
366 | 521 |
case 1: return R.string.color_white6; |
... | ... | |
375 | 530 |
|
376 | 531 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
377 | 532 |
|
378 |
private String edgeError(Resources res, int face0, int face1) |
|
533 |
private String edgeTwistedError(Resources res, int color0, int color1) |
|
534 |
{ |
|
535 |
int j0 = getColorIndex3(color0); |
|
536 |
int j1 = getColorIndex6(color1); |
|
537 |
|
|
538 |
String c0 = res.getString(j0); |
|
539 |
String c1 = res.getString(j1); |
|
540 |
|
|
541 |
return res.getString(R.string.solver_generic_twisted_edge,c0,c1); |
|
542 |
} |
|
543 |
|
|
544 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
545 |
|
|
546 |
private String cornerTwistedError(Resources res, int color0, int color1, int color2) |
|
547 |
{ |
|
548 |
int j0 = getColorIndex3(color0); |
|
549 |
int j1 = getColorIndex3(color1); |
|
550 |
int j2 = getColorIndex5(color2); |
|
551 |
|
|
552 |
String c0 = res.getString(j0); |
|
553 |
String c1 = res.getString(j1); |
|
554 |
String c2 = res.getString(j2); |
|
555 |
|
|
556 |
return res.getString(R.string.solver_generic_twisted_corner,c0,c1,c2); |
|
557 |
} |
|
558 |
|
|
559 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
560 |
|
|
561 |
private String edgeMissingError(Resources res, int color0, int color1) |
|
379 | 562 |
{ |
380 |
int j0 = getColorIndex3(face0);
|
|
381 |
int j1 = getColorIndex6(face1);
|
|
563 |
int j0 = getColorIndex3(color0);
|
|
564 |
int j1 = getColorIndex6(color1);
|
|
382 | 565 |
|
383 | 566 |
String c0 = res.getString(j0); |
384 | 567 |
String c1 = res.getString(j1); |
... | ... | |
388 | 571 |
|
389 | 572 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
390 | 573 |
|
391 |
private String cornerError(Resources res, int face0, int face1, int face2)
|
|
574 |
private String cornerMissingError(Resources res, int color0, int color1, int color2)
|
|
392 | 575 |
{ |
393 |
int j0 = getColorIndex3(face0);
|
|
394 |
int j1 = getColorIndex3(face1);
|
|
395 |
int j2 = getColorIndex4(face2);
|
|
576 |
int j0 = getColorIndex3(color0);
|
|
577 |
int j1 = getColorIndex3(color1);
|
|
578 |
int j2 = getColorIndex4(color2);
|
|
396 | 579 |
|
397 | 580 |
String c0 = res.getString(j0); |
398 | 581 |
String c1 = res.getString(j1); |
... | ... | |
407 | 590 |
{ |
408 | 591 |
switch(index) |
409 | 592 |
{ |
410 |
case ERROR_CORNER_MISSING : return cornerError(res,mErrorColor1,mErrorColor2,mErrorColor3); |
|
411 |
case ERROR_EDGE_MISSING : return edgeError(res,mErrorColor1,mErrorColor2); |
|
593 |
case ERROR_CORNER_MISSING : return cornerMissingError(res,mErrorColor1,mErrorColor2,mErrorColor3);
|
|
594 |
case ERROR_EDGE_MISSING : return edgeMissingError(res,mErrorColor1,mErrorColor2);
|
|
412 | 595 |
case ERROR_CORNERS_CANNOT : return res.getString(R.string.solver_generic_corners_cannot); |
413 |
case ERROR_EDGE_TWISTED : return res.getString(R.string.solver_generic_edge_twist);
|
|
414 |
case ERROR_CORNER_TWISTED : return res.getString(R.string.solver_generic_corner_twist);
|
|
596 |
case ERROR_EDGE_TWISTED : return edgeTwistedError(res,mErrorColor1,mErrorColor2);
|
|
597 |
case ERROR_CORNER_TWISTED : return cornerTwistedError(res,mErrorColor1,mErrorColor2,mErrorColor3);
|
|
415 | 598 |
} |
416 | 599 |
|
417 | 600 |
return null; |
Also available in: Unified diff
CU_323 solver: progress