Revision 4f2ad167
Added by Leszek Koltunski 8 months ago
| src/main/java/org/distorted/solvers/SolverSkewb.java | ||
|---|---|---|
| 9 | 9 |
|
| 10 | 10 |
package org.distorted.solvers; |
| 11 | 11 |
|
| 12 |
import static org.distorted.objectlib.tablebases.TBSkewb.FIXED; |
|
| 12 | 13 |
import static org.distorted.objectlib.tablebases.TBSkewb.FREE; |
| 13 | 14 |
|
| 14 | 15 |
import android.content.res.Resources; |
| ... | ... | |
| 47 | 48 |
private static final int ERROR_TWO_CENTERS = -17; |
| 48 | 49 |
private static final int ERROR_TWO_CORNERS = -18; |
| 49 | 50 |
|
| 51 |
private static final int ERROR_FREE_CORNERS_NOT_EVEN = -19; |
|
| 52 |
private static final int ERROR_FREE_CORNERS_ROTATED = -20; |
|
| 53 |
|
|
| 50 | 54 |
private TablebasesAbstract mSolver; |
| 51 | 55 |
private final int[] mFaceColors; |
| 52 | 56 |
|
| ... | ... | |
| 69 | 73 |
|
| 70 | 74 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 71 | 75 |
|
| 72 |
private int getCenters(TwistyObject object, int[] output) |
|
| 76 |
private void createCenterPermutation(int[] output, int[] symbols, int[] perm) |
|
| 77 |
{
|
|
| 78 |
for(int s=0; s<6; s++) |
|
| 79 |
{
|
|
| 80 |
int symbol = symbols[s]; |
|
| 81 |
|
|
| 82 |
for(int p=0; p<6; p++) |
|
| 83 |
if( perm[p]==symbol ) |
|
| 84 |
{
|
|
| 85 |
output[s] = p; |
|
| 86 |
break; |
|
| 87 |
} |
|
| 88 |
} |
|
| 89 |
} |
|
| 90 |
|
|
| 91 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 92 |
|
|
| 93 |
private int getCenters(TwistyObject object, int[] out) |
|
| 73 | 94 |
{
|
| 74 | 95 |
final int[] map = {4,5,2,3,0,1};
|
| 75 |
int[] inverted_perm = new int[6]; |
|
| 96 |
int[] tmp = new int[6]; |
|
| 97 |
int[] mcl = new int[6]; |
|
| 76 | 98 |
boolean[] present = new boolean[6]; |
| 77 | 99 |
|
| 78 | 100 |
for(int i=0; i<6; i++) |
| 79 | 101 |
{
|
| 80 | 102 |
int color = object.getCubitFaceStickerIndex(i+8,0) - 6; |
| 81 | 103 |
present[color] = true; |
| 82 |
inverted_perm[i] = map[mFaceColors[color]];
|
|
| 104 |
tmp[i] = color;
|
|
| 83 | 105 |
} |
| 84 | 106 |
|
| 85 | 107 |
if( !present[0] ) return ERROR_CENTER_0_MISSING; |
| ... | ... | |
| 89 | 111 |
if( !present[4] ) return ERROR_CENTER_4_MISSING; |
| 90 | 112 |
if( !present[5] ) return ERROR_CENTER_5_MISSING; |
| 91 | 113 |
|
| 92 |
TablebaseHelpers.invertPermutation(inverted_perm,output); |
|
| 114 |
for(int i=0; i<6; i++) mcl[i] = map[mFaceColors[i]]; |
|
| 115 |
createCenterPermutation(out,mcl,tmp); |
|
| 116 |
|
|
| 93 | 117 |
return 0; |
| 94 | 118 |
} |
| 95 | 119 |
|
| ... | ... | |
| 198 | 222 |
return 0; |
| 199 | 223 |
} |
| 200 | 224 |
|
| 201 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 202 |
|
|
| 203 |
private int retCornerPerm(int index, int[] perm) |
|
| 204 |
{
|
|
| 205 |
switch(index) |
|
| 206 |
{
|
|
| 207 |
case 0: return 0; |
|
| 208 |
case 1: return FREE[perm[0]]; |
|
| 209 |
case 2: return FREE[perm[1]]; |
|
| 210 |
case 3: return 3; |
|
| 211 |
case 4: return FREE[perm[2]]; |
|
| 212 |
case 5: return 5; |
|
| 213 |
case 6: return 6; |
|
| 214 |
case 7: return FREE[perm[3]]; |
|
| 215 |
} |
|
| 216 |
|
|
| 217 |
return -1; |
|
| 218 |
} |
|
| 219 |
|
|
| 220 | 225 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 221 | 226 |
|
| 222 | 227 |
private void computeCornerQuats(int[] quats, int[][] corners, int[] perm) |
| ... | ... | |
| 224 | 229 |
final int[] zeroeth_face_map = { 4,2,3,5,1,5,4,1 };
|
| 225 | 230 |
int[] twist = new int[8]; |
| 226 | 231 |
|
| 227 |
for(int i=0; i<8; i++)
|
|
| 232 |
for(int i=0; i<4; i++)
|
|
| 228 | 233 |
{
|
| 229 |
int color = mFaceColors[zeroeth_face_map[i]]; |
|
| 230 |
int[] c = corners[retCornerPerm(i,perm)]; |
|
| 234 |
int fi = FIXED[i]; |
|
| 235 |
int colorFi = mFaceColors[zeroeth_face_map[fi]]; |
|
| 236 |
int[] cFi = corners[fi]; |
|
| 231 | 237 |
|
| 232 |
if( c[0]==color ) twist[i] = 0;
|
|
| 233 |
else if( c[1]==color ) twist[i] = 1;
|
|
| 234 |
else twist[i] = 2;
|
|
| 238 |
if( cFi[0]==colorFi ) twist[fi] = 0;
|
|
| 239 |
else if( cFi[1]==colorFi ) twist[fi] = 1;
|
|
| 240 |
else twist[fi] = 2;
|
|
| 235 | 241 |
} |
| 236 | 242 |
|
| 243 |
int[] inv_perm = new int[4]; |
|
| 244 |
TablebaseHelpers.invertPermutation(perm,inv_perm); |
|
| 245 |
|
|
| 246 |
int common14 = commonCornerColor(corners[1], corners[4]); |
|
| 247 |
int common27 = commonCornerColor(corners[2], corners[7]); |
|
| 248 |
int common47 = commonCornerColor(corners[4], corners[7]); |
|
| 249 |
int index; |
|
| 250 |
int[] c; |
|
| 251 |
|
|
| 252 |
index = FREE[inv_perm[0]]; |
|
| 253 |
c = corners[FREE[0]]; |
|
| 254 |
|
|
| 255 |
if(c[0]==common14) twist[index] = 0; |
|
| 256 |
else if(c[1]==common14) twist[index] = 2; |
|
| 257 |
else twist[index] = 1; |
|
| 258 |
|
|
| 259 |
index = FREE[inv_perm[1]]; |
|
| 260 |
c = corners[FREE[1]]; |
|
| 261 |
|
|
| 262 |
if(c[0]==common27) twist[index] = 0; |
|
| 263 |
else if(c[1]==common27) twist[index] = 2; |
|
| 264 |
else twist[index] = 1; |
|
| 265 |
|
|
| 266 |
index = FREE[inv_perm[2]]; |
|
| 267 |
c = corners[FREE[2]]; |
|
| 268 |
|
|
| 269 |
if(c[0]==common47) twist[index] = 0; |
|
| 270 |
else if(c[1]==common47) twist[index] = 2; |
|
| 271 |
else twist[index] = 1; |
|
| 272 |
|
|
| 273 |
index = FREE[inv_perm[3]]; |
|
| 274 |
c = corners[FREE[3]]; |
|
| 275 |
|
|
| 276 |
if(c[0]==common47) twist[index] = 0; |
|
| 277 |
else if(c[1]==common47) twist[index] = 2; |
|
| 278 |
else twist[index] = 1; |
|
| 279 |
|
|
| 237 | 280 |
TBSkewb.fillInQuats(quats,perm,twist); |
| 238 | 281 |
} |
| 239 | 282 |
|
| ... | ... | |
| 265 | 308 |
if( result4<0 ) return result4; |
| 266 | 309 |
|
| 267 | 310 |
computeCornerQuats(quats,corners,freePerm); |
| 311 |
|
|
| 312 |
int[] freeLoc = new int[4]; |
|
| 313 |
for(int f=0; f<4; f++) freeLoc[f] = TBSkewb.computeLocation(f,quats[FREE[f]]); |
|
| 314 |
if( !TablebaseHelpers.permutationIsEven(freeLoc) ) return ERROR_FREE_CORNERS_NOT_EVEN; |
|
| 315 |
|
|
| 268 | 316 |
TBSkewb.computeCornerTwists(twist,quats); |
| 269 | 317 |
|
| 270 | 318 |
int total = 0; |
| 271 |
for(int i=0; i<4; i++) total += twist[FREE[i]];
|
|
| 319 |
for(int i=0; i<8; i++) total += twist[i];
|
|
| 272 | 320 |
if( (total%3)!=0 ) return ERROR_CORNER_TWISTED; |
| 273 | 321 |
int totalTwist = twist[0]+ 3*(twist[1]+ 3*(twist[2]+ 3*(twist[3]+ 3*(twist[4]+ 3*(twist[5]+ 3*twist[6]))))); |
| 274 | 322 |
|
| 275 |
int locationOfFree0 = TBSkewb.computeLocation(0,quats[1]); |
|
| 323 |
int sumFixedTwists = twist[FIXED[0]]+twist[FIXED[1]]+twist[FIXED[2]]+twist[FIXED[3]]; |
|
| 324 |
int freeLoc1 = TBSkewb.permFree1(freeLoc[0],sumFixedTwists); |
|
| 325 |
if( freeLoc[1] != freeLoc1 ) return ERROR_FREE_CORNERS_ROTATED; |
|
| 276 | 326 |
|
| 277 |
return center_perm_num+ 360*(totalTwist + 2187*locationOfFree0);
|
|
| 327 |
return center_perm_num+ 360*(totalTwist + 2187*freeLoc[0]);
|
|
| 278 | 328 |
} |
| 279 | 329 |
|
| 280 | 330 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 358 | 408 |
{
|
| 359 | 409 |
switch(index) |
| 360 | 410 |
{
|
| 361 |
case ERROR_CORNER_135_MISSING: return cornerError(res,1,3,5); |
|
| 362 |
case ERROR_CORNER_134_MISSING: return cornerError(res,1,3,4); |
|
| 363 |
case ERROR_CORNER_125_MISSING: return cornerError(res,1,2,5); |
|
| 364 |
case ERROR_CORNER_124_MISSING: return cornerError(res,1,2,4); |
|
| 365 |
case ERROR_CORNER_035_MISSING: return cornerError(res,0,3,5); |
|
| 366 |
case ERROR_CORNER_034_MISSING: return cornerError(res,0,3,4); |
|
| 367 |
case ERROR_CORNER_025_MISSING: return cornerError(res,0,2,5); |
|
| 368 |
case ERROR_CORNER_024_MISSING: return cornerError(res,0,2,4); |
|
| 369 |
|
|
| 370 |
case ERROR_CENTER_0_MISSING : return centerError(res,0); |
|
| 371 |
case ERROR_CENTER_1_MISSING : return centerError(res,1); |
|
| 372 |
case ERROR_CENTER_2_MISSING : return centerError(res,2); |
|
| 373 |
case ERROR_CENTER_3_MISSING : return centerError(res,3); |
|
| 374 |
case ERROR_CENTER_4_MISSING : return centerError(res,4); |
|
| 375 |
case ERROR_CENTER_5_MISSING : return centerError(res,5); |
|
| 376 |
|
|
| 377 |
case ERROR_CORNERS_CANNOT : return res.getString(R.string.solver_generic_corners_cannot); |
|
| 378 |
case ERROR_CORNER_TWISTED : return res.getString(R.string.solver_generic_corner_twist); |
|
| 379 |
case ERROR_TWO_CENTERS : return res.getString(R.string.solver_generic_two_centers); |
|
| 380 |
case ERROR_TWO_CORNERS : return res.getString(R.string.solver_generic_two_corners); |
|
| 411 |
case ERROR_CORNER_135_MISSING : return cornerError(res,1,3,5); |
|
| 412 |
case ERROR_CORNER_134_MISSING : return cornerError(res,1,3,4); |
|
| 413 |
case ERROR_CORNER_125_MISSING : return cornerError(res,1,2,5); |
|
| 414 |
case ERROR_CORNER_124_MISSING : return cornerError(res,1,2,4); |
|
| 415 |
case ERROR_CORNER_035_MISSING : return cornerError(res,0,3,5); |
|
| 416 |
case ERROR_CORNER_034_MISSING : return cornerError(res,0,3,4); |
|
| 417 |
case ERROR_CORNER_025_MISSING : return cornerError(res,0,2,5); |
|
| 418 |
case ERROR_CORNER_024_MISSING : return cornerError(res,0,2,4); |
|
| 419 |
|
|
| 420 |
case ERROR_CENTER_0_MISSING : return centerError(res,0); |
|
| 421 |
case ERROR_CENTER_1_MISSING : return centerError(res,1); |
|
| 422 |
case ERROR_CENTER_2_MISSING : return centerError(res,2); |
|
| 423 |
case ERROR_CENTER_3_MISSING : return centerError(res,3); |
|
| 424 |
case ERROR_CENTER_4_MISSING : return centerError(res,4); |
|
| 425 |
case ERROR_CENTER_5_MISSING : return centerError(res,5); |
|
| 426 |
|
|
| 427 |
case ERROR_CORNERS_CANNOT : return res.getString(R.string.solver_generic_corners_cannot); |
|
| 428 |
case ERROR_CORNER_TWISTED : return res.getString(R.string.solver_generic_corner_twist); |
|
| 429 |
case ERROR_TWO_CENTERS : return res.getString(R.string.solver_generic_two_centers); |
|
| 430 |
case ERROR_TWO_CORNERS : return res.getString(R.string.solver_generic_two_corners); |
|
| 431 |
|
|
| 432 |
case ERROR_FREE_CORNERS_NOT_EVEN: return res.getString(R.string.solver_generic_free_corners_odd); |
|
| 433 |
case ERROR_FREE_CORNERS_ROTATED : return res.getString(R.string.solver_generic_free_corners_rotated); |
|
| 381 | 434 |
} |
| 382 | 435 |
|
| 383 | 436 |
return null; |
Also available in: Unified diff
Fix SkewbSolver.