Revision 62c08ea7
Added by Leszek Koltunski almost 2 years ago
src/main/java/org/distorted/solvers/SolverSkewbDiamond.java | ||
---|---|---|
14 | 14 |
import org.distorted.objectlib.main.ObjectType; |
15 | 15 |
import org.distorted.objectlib.main.TwistyObject; |
16 | 16 |
import org.distorted.objectlib.tablebases.ImplementedTablebasesList; |
17 |
import org.distorted.objectlib.tablebases.TablebaseHelpers; |
|
17 | 18 |
import org.distorted.objectlib.tablebases.TablebasesAbstract; |
18 | 19 |
|
19 | 20 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
39 | 40 |
private static final int ERROR_TWO_CORNERS = -15; |
40 | 41 |
private static final int ERROR_TWO_CENTERS = -16; |
41 | 42 |
private static final int ERROR_CORNER_TWIST = -17; |
43 |
private static final int ERROR_CORNERS_CANNOT = -18; |
|
42 | 44 |
|
43 | 45 |
private TablebasesAbstract mSolver; |
44 | 46 |
|
... | ... | |
49 | 51 |
super(res,object); |
50 | 52 |
} |
51 | 53 |
|
54 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
55 |
|
|
56 |
private int[] getCornersPermutation(int[] colors, int[][] corners) |
|
57 |
{ |
|
58 |
|
|
59 |
} |
|
60 |
|
|
61 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
62 |
|
|
63 |
private int[] getCornersTwist(int[] colors, int[][] corners) |
|
64 |
{ |
|
65 |
|
|
66 |
} |
|
67 |
|
|
68 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
69 |
|
|
70 |
private int[] getFreeCentersPermutation(int[] colors, int[] centers) |
|
71 |
{ |
|
72 |
|
|
73 |
} |
|
74 |
|
|
75 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
76 |
|
|
77 |
private int getTotalTwist(int[] twist) |
|
78 |
{ |
|
79 |
int total = 0; |
|
80 |
|
|
81 |
for(int i=0; i<6; i++) |
|
82 |
{ |
|
83 |
int t= twist[i]; |
|
84 |
if( t==1 || t==3 ) return -1; |
|
85 |
if( t==2 ) total++; |
|
86 |
total *= 2; |
|
87 |
} |
|
88 |
|
|
89 |
return total; |
|
90 |
} |
|
91 |
|
|
92 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
93 |
|
|
94 |
private int figureOutColor(int[][] corners, int c1, int c2) |
|
95 |
{ |
|
96 |
for(int i=0; i<6; i++) |
|
97 |
{ |
|
98 |
int[] cor = corners[i]; |
|
99 |
|
|
100 |
if( cor[0]==c1 && cor[2]==c2 ) return cor[1]; |
|
101 |
if( cor[1]==c1 && cor[3]==c2 ) return cor[2]; |
|
102 |
if( cor[2]==c1 && cor[0]==c2 ) return cor[3]; |
|
103 |
if( cor[3]==c1 && cor[1]==c2 ) return cor[0]; |
|
104 |
} |
|
105 |
|
|
106 |
return -1; |
|
107 |
} |
|
108 |
|
|
109 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
110 |
// We only move the UR, UR, DR & DB faces --> those centers are fixed and determine the colors of |
|
111 |
// the faces. |
|
112 |
|
|
113 |
private int figureOutFaceColors(int[] output, int[] centers, int[][] corners) |
|
114 |
{ |
|
115 |
output[1] = centers[1]; |
|
116 |
output[3] = centers[3]; |
|
117 |
output[4] = centers[4]; |
|
118 |
output[6] = centers[6]; |
|
119 |
|
|
120 |
int color01 = figureOutColor(corners,output[4],output[1]); |
|
121 |
if( color01<0 ) return ERROR_CORNER_FR_MISSING; |
|
122 |
int color02 = figureOutColor(corners,output[3],output[4]); |
|
123 |
if( color02<0 ) return ERROR_CORNER_FL_MISSING; |
|
124 |
int color03 = figureOutColor(corners,output[1],output[3]); |
|
125 |
if( color03<0 ) return ERROR_CORNER_TO_MISSING; |
|
126 |
if( color01!=color02 || color01!=color03 ) return ERROR_CORNERS_CANNOT; |
|
127 |
output[0] = color01; |
|
128 |
|
|
129 |
int color21 = figureOutColor(corners,output[1],output[6]); |
|
130 |
if( color21<0 ) return ERROR_CORNER_BR_MISSING; |
|
131 |
int color22 = figureOutColor(corners,output[6],output[3]); |
|
132 |
if( color22<0 ) return ERROR_CORNER_BL_MISSING; |
|
133 |
int color23 = figureOutColor(corners,output[3],output[1]); |
|
134 |
if( color23<0 ) return ERROR_CORNER_TO_MISSING; |
|
135 |
if( color21!=color22 || color21!=color23 ) return ERROR_CORNERS_CANNOT; |
|
136 |
output[2] = color21; |
|
137 |
|
|
138 |
int color51 = figureOutColor(corners,output[1],output[4]); |
|
139 |
if( color51<0 ) return ERROR_CORNER_FR_MISSING; |
|
140 |
int color52 = figureOutColor(corners,output[6],output[1]); |
|
141 |
if( color52<0 ) return ERROR_CORNER_BR_MISSING; |
|
142 |
int color53 = figureOutColor(corners,output[4],output[6]); |
|
143 |
if( color53<0 ) return ERROR_CORNER_BO_MISSING; |
|
144 |
if( color51!=color52 || color51!=color53 ) return ERROR_CORNERS_CANNOT; |
|
145 |
output[5] = color51; |
|
146 |
|
|
147 |
int color71 = figureOutColor(corners,output[3],output[6]); |
|
148 |
if( color71<0 ) return ERROR_CORNER_BL_MISSING; |
|
149 |
int color72 = figureOutColor(corners,output[4],output[3]); |
|
150 |
if( color72<0 ) return ERROR_CORNER_FL_MISSING; |
|
151 |
int color73 = figureOutColor(corners,output[6],output[4]); |
|
152 |
if( color73<0 ) return ERROR_CORNER_BO_MISSING; |
|
153 |
if( color71!=color72 || color71!=color73 ) return ERROR_CORNERS_CANNOT; |
|
154 |
output[7] = color71; |
|
155 |
|
|
156 |
return 0; |
|
157 |
} |
|
158 |
|
|
159 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
160 |
|
|
161 |
private int checkAllColorsDifferent(int[] colors) |
|
162 |
{ |
|
163 |
for(int i=0; i<8; i++) |
|
164 |
{ |
|
165 |
boolean present = false; |
|
166 |
|
|
167 |
for(int j=0; j<8; j++) |
|
168 |
if( colors[j]==i ) |
|
169 |
{ |
|
170 |
present=true; |
|
171 |
break; |
|
172 |
} |
|
173 |
|
|
174 |
if( !present ) return ERROR_CORNERS_CANNOT; |
|
175 |
} |
|
176 |
|
|
177 |
return 0; |
|
178 |
} |
|
179 |
|
|
52 | 180 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
53 | 181 |
|
54 | 182 |
private int checkAllCentersPresent(int[] centers) |
55 | 183 |
{ |
184 |
for(int i=0; i<8; i++) |
|
185 |
{ |
|
186 |
boolean present = false; |
|
187 |
|
|
188 |
for(int j=0; j<8; j++) |
|
189 |
if( centers[j]==i ) |
|
190 |
{ |
|
191 |
present=true; |
|
192 |
break; |
|
193 |
} |
|
194 |
|
|
195 |
if( !present ) |
|
196 |
{ |
|
197 |
switch(i) |
|
198 |
{ |
|
199 |
case 0: return ERROR_CENTER_0_MISSING; |
|
200 |
case 1: return ERROR_CENTER_1_MISSING; |
|
201 |
case 2: return ERROR_CENTER_2_MISSING; |
|
202 |
case 3: return ERROR_CENTER_3_MISSING; |
|
203 |
case 4: return ERROR_CENTER_4_MISSING; |
|
204 |
case 5: return ERROR_CENTER_5_MISSING; |
|
205 |
case 6: return ERROR_CENTER_6_MISSING; |
|
206 |
case 7: return ERROR_CENTER_7_MISSING; |
|
207 |
} |
|
208 |
} |
|
209 |
} |
|
210 |
|
|
56 | 211 |
return 0; |
57 | 212 |
} |
58 | 213 |
|
... | ... | |
95 | 250 |
|
96 | 251 |
private void getCenters(TwistyObject object, int[] centers) |
97 | 252 |
{ |
98 |
centers[0] = object.getCubitFaceStickerIndex( 6,0); // UR
|
|
99 |
centers[1] = object.getCubitFaceStickerIndex( 8,0); // UL
|
|
100 |
centers[2] = object.getCubitFaceStickerIndex(11,0); // DB
|
|
101 |
centers[3] = object.getCubitFaceStickerIndex(13,0); // DF
|
|
102 |
centers[4] = object.getCubitFaceStickerIndex( 9,0); // UF
|
|
103 |
centers[5] = object.getCubitFaceStickerIndex( 7,0); // UB
|
|
104 |
centers[6] = object.getCubitFaceStickerIndex(12,0); // DL
|
|
105 |
centers[7] = object.getCubitFaceStickerIndex(10,1); // DR
|
|
253 |
centers[0] = object.getCubitFaceStickerIndex( 9,0); // UF
|
|
254 |
centers[1] = object.getCubitFaceStickerIndex( 6,0); // UR
|
|
255 |
centers[2] = object.getCubitFaceStickerIndex( 7,0); // UB
|
|
256 |
centers[3] = object.getCubitFaceStickerIndex( 8,0); // UL
|
|
257 |
centers[4] = object.getCubitFaceStickerIndex(13,0); // DF
|
|
258 |
centers[5] = object.getCubitFaceStickerIndex(10,1); // DR
|
|
259 |
centers[6] = object.getCubitFaceStickerIndex(11,0); // DB
|
|
260 |
centers[7] = object.getCubitFaceStickerIndex(12,0); // DL
|
|
106 | 261 |
} |
107 | 262 |
|
108 | 263 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
111 | 266 |
{ |
112 | 267 |
int[][] corners = new int[6][4]; |
113 | 268 |
int[] centers = new int[8]; |
269 |
int[] face_colors = new int[8]; |
|
114 | 270 |
|
115 | 271 |
getCorners(object,corners); |
116 | 272 |
getCenters(object,centers); |
... | ... | |
118 | 274 |
int result1 = checkAllCentersPresent(centers); |
119 | 275 |
if( result1<0 ) return result1; |
120 | 276 |
|
121 |
return 0; |
|
277 |
int result2 = figureOutFaceColors(face_colors,centers,corners); |
|
278 |
if( result2<0 ) return result2; |
|
279 |
|
|
280 |
int result3 = checkAllColorsDifferent(face_colors); |
|
281 |
if( result3<0 ) return result3; |
|
282 |
|
|
283 |
int[] corners_perm = getCornersPermutation(face_colors, corners); |
|
284 |
boolean even1 = TablebaseHelpers.permutationIsEven(corners_perm); |
|
285 |
if( !even1 ) return ERROR_TWO_CORNERS; |
|
286 |
|
|
287 |
int[] free_centers_perm = getFreeCentersPermutation(face_colors, centers); |
|
288 |
boolean even2 = TablebaseHelpers.permutationIsEven(free_centers_perm); |
|
289 |
if( !even2 ) return ERROR_TWO_CENTERS; |
|
290 |
|
|
291 |
int[] corners_twist = getCornersTwist(face_colors, corners); |
|
292 |
int totalTwist = getTotalTwist(corners_twist); |
|
293 |
if( totalTwist<0 ) return ERROR_CORNER_TWIST; |
|
294 |
|
|
295 |
int corners_perm_num = TablebaseHelpers.computeEvenPermutationNum(corners_perm); |
|
296 |
int centers_perm_num = TablebaseHelpers.computeEvenPermutationNum(free_centers_perm); |
|
297 |
|
|
298 |
return centers_perm_num + 12*(totalTwist + 128*corners_perm_num); |
|
122 | 299 |
} |
123 | 300 |
|
124 | 301 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
127 | 304 |
{ |
128 | 305 |
switch(index) |
129 | 306 |
{ |
130 |
/* |
|
131 |
private static final int ERROR_CORNER_FR_MISSING = -1; |
|
132 |
private static final int ERROR_CORNER_BR_MISSING = -2; |
|
133 |
private static final int ERROR_CORNER_BL_MISSING = -3; |
|
134 |
private static final int ERROR_CORNER_FL_MISSING = -4; |
|
135 |
private static final int ERROR_CORNER_TO_MISSING = -5; |
|
136 |
private static final int ERROR_CORNER_BO_MISSING = -6; |
|
137 |
|
|
138 |
private static final int ERROR_CENTER_0_MISSING = -7; |
|
139 |
private static final int ERROR_CENTER_1_MISSING = -8; |
|
140 |
private static final int ERROR_CENTER_2_MISSING = -9; |
|
141 |
private static final int ERROR_CENTER_3_MISSING = -10; |
|
142 |
private static final int ERROR_CENTER_4_MISSING = -11; |
|
143 |
private static final int ERROR_CENTER_5_MISSING = -12; |
|
144 |
private static final int ERROR_CENTER_6_MISSING = -13; |
|
145 |
private static final int ERROR_CENTER_7_MISSING = -14; |
|
146 |
|
|
147 |
private static final int ERROR_TWO_CORNERS = -15; |
|
148 |
private static final int ERROR_TWO_CENTERS = -16; |
|
149 |
private static final int ERROR_CORNER_TWIST = -17; |
|
150 |
|
|
151 |
*/ |
|
307 |
case ERROR_CORNER_FR_MISSING: |
|
308 |
case ERROR_CORNER_BR_MISSING: |
|
309 |
case ERROR_CORNER_BL_MISSING: |
|
310 |
case ERROR_CORNER_FL_MISSING: |
|
311 |
case ERROR_CORNER_TO_MISSING: |
|
312 |
case ERROR_CORNER_BO_MISSING: |
|
313 |
|
|
314 |
case ERROR_CENTER_0_MISSING : |
|
315 |
case ERROR_CENTER_1_MISSING : |
|
316 |
case ERROR_CENTER_2_MISSING : |
|
317 |
case ERROR_CENTER_3_MISSING : |
|
318 |
case ERROR_CENTER_4_MISSING : |
|
319 |
case ERROR_CENTER_5_MISSING : |
|
320 |
case ERROR_CENTER_6_MISSING : |
|
321 |
case ERROR_CENTER_7_MISSING : |
|
322 |
|
|
323 |
case ERROR_TWO_CORNERS : |
|
324 |
case ERROR_TWO_CENTERS : |
|
325 |
case ERROR_CORNER_TWIST : |
|
326 |
case ERROR_CORNERS_CANNOT : |
|
152 | 327 |
} |
153 | 328 |
|
154 | 329 |
return null; |
Also available in: Unified diff
Progress with Skewb Diamond solver.