/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision cff92952

Added by Leszek Koltunski almost 2 years ago

ID cff92952d74eae62c588122fc4e6e012e2c92609
Parent 713af0c5
Child 14cf0761

Progess with Skewb solver.

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int tablebaseIndex(TwistyObject object)
       private void getCorners(TwistyObject object, int[][] corners)
+        {
         int[][] corners= new int[8][3];
         corners[0][0] = object.getCubitFaceStickerIndex(0,1);
         corners[0][1] = object.getCubitFaceStickerIndex(0,3);
         corners[0][2] = object.getCubitFaceStickerIndex(0,5);
-...
         corners[7][0] = object.getCubitFaceStickerIndex(7,1);
         corners[7][1] = object.getCubitFaceStickerIndex(7,3);
         corners[7][2] = object.getCubitFaceStickerIndex(7,5);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int tablebaseIndex(TwistyObject object)
+        {
         int[][] corners= new int[8][3];
         getCorners(object,corners);
         int result0 = computeFaceColors(corners);
         if( result0<0 ) return result0;

       private static final int ERROR_CENTER_B_MISSING = -7;
       private static final int ERROR_CENTER_R_MISSING = -8;
       private static final int ERROR_TWO_CENTERS_SWAP = -9;
       private static final int ERROR_TWO_CENTERS      = -9;
       private static final int ERROR_CORNER_TWISTED   = -10;
       private static final int ERROR_CORNERS_CANNOT   = -11;
-...
         int twist_gr = computeCenterTwist(centers,faces[1],faces[2]);
         int twist_ry = computeCenterTwist(centers,faces[2],faces[0]);
         if( (twist_ry-twist_gr+1)%3 != 0 ) return ERROR_TWO_CENTERS_SWAP;
         if( (twist_ry-twist_gr+1)%3 != 0 ) return ERROR_TWO_CENTERS;
         int total_twist=0;
-...
                                          return res.getString(R.string.solver_generic_missing_center,colorB);
           case ERROR_CENTER_R_MISSING  : String colorR = res.getString(R.string.color_red2);
                                          return res.getString(R.string.solver_generic_missing_center,colorR);
           case ERROR_TWO_CENTERS_SWAP  : return res.getString(R.string.solver_generic_two_centers);
           case ERROR_TWO_CENTERS       : return res.getString(R.string.solver_generic_two_centers);
           case ERROR_CORNER_TWISTED    : return res.getString(R.string.solver_generic_corner_twist);
           case ERROR_CORNERS_CANNOT    : return res.getString(R.string.solver_generic_corners_cannot);
+          }

     import org.distorted.objectlib.main.ObjectSignatures;
     import org.distorted.objectlib.main.TwistyObject;
     import org.distorted.objectlib.tablebases.ImplementedTablebasesList;
     import org.distorted.objectlib.tablebases.TablebaseHelpers;
     import org.distorted.objectlib.tablebases.TablebasesAbstract;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       private static final int ERROR_TWO_CENTERS        = -17;
       private static final int ERROR_TWO_CORNERS        = -18;
       private static final int ERROR_IMPOSSIBLE         = -19;
       private TablebasesAbstract mSolver;
       private int[] mFaceColors;
       private final int[] mFaceColors;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public SolverSkewb(Resources res, TwistyObject object)
+        {
         super(res,object);
         mFaceColors = new int[6];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void getCorners(TwistyObject object, int[][] corners)
+        {
         for(int i=0; i<8; i++)
           for(int j=0; j<3; j++)
             corners[i][j] = object.getCubitFaceStickerIndex(i,j);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void getCenters(TwistyObject object, int[] centers)
+        {
         int[] map = {12,13,10,11,8,9};
         for(int i=0; i<6; i++)
           centers[i] = object.getCubitFaceStickerIndex(map[i],0) - 6;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int checkAllCornersPresent(int[][] corners)
       private int commonCornerColor(int[] c1, int[] c2)
+        {
         int theSame = 0;
         int index   = 0;
         for(int i=0; i<3; i++)
           for(int j=0; j<3; j++)
             if( c1[i]==c2[j] )
+              {
               index = i;
               theSame++;
+              }
         return theSame==1 ? c1[index] : ERROR_CORNERS_CANNOT;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int computeFaceColors(int[][] corners, int[] output)
+        {
         final int[][] map = { {0,3},{5,6},{0,5},{6,3},{0,6},{3,5} };
         for(int i=0; i<6; i++)
+          {
           int c1 = map[i][0];
           int c2 = map[i][1];
           output[i] = commonCornerColor(corners[c1],corners[c2]);
           if( output[i]<0 ) return ERROR_CORNERS_CANNOT;
+          }
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int[] computeFaceColors(int[][] corners)
       private boolean cornerIs(int[] corner, int c0, int c1, int c2)
+        {
         return null;
         return ( (corner[0]==c0 && corner[1]==c1 && corner[2]==c2 ) ||
                  (corner[1]==c0 && corner[2]==c1 && corner[0]==c2 ) ||
                  (corner[2]==c0 && corner[0]==c1 && corner[1]==c2 )  );
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void getCenters(TwistyObject object, int[] centers)
       private int checkAllCornersPresent(int[][] corners)
+        {
         boolean[] present = new boolean[8];
         for(int i=0; i<8; i++)
+          {
           if( cornerIs(corners[i],4,2,0) ) present[0]=true;
           if( cornerIs(corners[i],2,5,0) ) present[1]=true;
           if( cornerIs(corners[i],3,4,0) ) present[2]=true;
           if( cornerIs(corners[i],5,3,0) ) present[3]=true;
           if( cornerIs(corners[i],1,2,4) ) present[4]=true;
           if( cornerIs(corners[i],5,2,1) ) present[5]=true;
           if( cornerIs(corners[i],4,3,1) ) present[6]=true;
           if( cornerIs(corners[i],1,3,5) ) present[7]=true;
+          }
         if( !present[0] ) return ERROR_CORNER_024_MISSING;
         if( !present[1] ) return ERROR_CORNER_025_MISSING;
         if( !present[2] ) return ERROR_CORNER_034_MISSING;
         if( !present[3] ) return ERROR_CORNER_035_MISSING;
         if( !present[4] ) return ERROR_CORNER_124_MISSING;
         if( !present[5] ) return ERROR_CORNER_125_MISSING;
         if( !present[6] ) return ERROR_CORNER_134_MISSING;
         if( !present[7] ) return ERROR_CORNER_135_MISSING;
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int checkAllCentersPresent(int[] centers)
+        {
         boolean[] present = new boolean[6];
         for(int i=0; i<6; i++) present[centers[i]]= true;
         if( !present[0] ) return ERROR_CENTER_4_MISSING;
         if( !present[1] ) return ERROR_CENTER_5_MISSING;
         if( !present[2] ) return ERROR_CENTER_2_MISSING;
         if( !present[3] ) return ERROR_CENTER_3_MISSING;
         if( !present[4] ) return ERROR_CENTER_0_MISSING;
         if( !present[5] ) return ERROR_CENTER_1_MISSING;
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // free corners: 1,2,4,7
       private int retCornerPermutation(int[] perm, int[][] corners)
+        {
         int[] map = {1,2,4,7};
         perm[0] =  0;
         perm[1] = -1;
         perm[2] = -1;
         perm[3] =  3;
         perm[4] = -1;
         perm[5] =  5;
         perm[6] =  6;
         perm[7] = -1;
         for(int i=0; i<4; i++)
+          {
           int index = map[i];
           int[] cor = corners[index];
           if( cornerIs(cor,2,5,0) ) perm[1] = index;
           if( cornerIs(cor,3,4,0) ) perm[2] = index;
           if( cornerIs(cor,1,2,4) ) perm[4] = index;
           if( cornerIs(cor,1,3,5) ) perm[7] = index;
+          }
         if( perm[1]==-1 ) return ERROR_CORNER_025_MISSING;
         if( perm[2]==-1 ) return ERROR_CORNER_034_MISSING;
         if( perm[4]==-1 ) return ERROR_CORNER_124_MISSING;
         if( perm[7]==-1 ) return ERROR_CORNER_135_MISSING;
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void fillCornerTwists(int[] output, int[][] corners, int[] perm)
+        {
         final int[] map = { 4,2,3,5,1,5,4,1 };
         for(int i=0; i<8; i++)
+          {
           int color = mFaceColors[map[i]];
           int[] c = corners[perm[i]];
                if( c[0]==color ) output[i] = 0;
           else if( c[1]==color ) output[i] = 1;
           else                   output[i] = 2;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int computeCenterTwist(int p1, int p2)
+        {
         if( p1==1 )
+          {
           switch(p2)
+            {
             case 2: return 2;
             case 4: return 1;
             case 7: return 0;
+            }
+          }
         if( p1==2 )
+          {
           switch(p2)
+            {
             case 1: return 2;
             case 4: return 0;
             case 7: return 1;
+            }
+          }
         if( p1==4 )
+          {
           switch(p2)
+            {
             case 1: return 1;
             case 2: return 0;
             case 7: return 2;
+            }
+          }
         if( p1==7 )
+          {
           switch(p2)
+            {
             case 1: return 0;
             case 2: return 1;
             case 4: return 2;
+            }
+          }
         return ERROR_IMPOSSIBLE;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int positionOfFirstCorner(int[] perm, int[] twist)
+        {
         int total_fixed_twist = twist[0]+twist[3]+twist[5]+twist[6];
         int twist_42 = computeCenterTwist(perm[4],perm[2]);
         int twist_21 = computeCenterTwist(perm[2],perm[1]);
         if( twist_42<0 || twist_21<0 ) return ERROR_IMPOSSIBLE;
     android.util.Log.e("D", "twist42 "+twist_42+" twist21 "+twist_21+" total: "+total_fixed_twist);
         if( (twist_21-twist_42+1)%3 != 0 ) return ERROR_TWO_CORNERS;
         if( (total_fixed_twist-twist_42)%3 !=0 ) return ERROR_CORNER_TWISTED;
         switch(perm[1])
+          {
           case 1: return 0;
           case 2: return 1;
           case 4: return 2;
           case 7: return 3;
+          }
         return ERROR_IMPOSSIBLE;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int tablebaseIndex(TwistyObject object)
+        {
         int[][] corners   = new int[6][3];
         int[] centers     = new int[6];
         int[] corner_twist= new int[6];
         int[][] corners= new int[8][3];
         int[] centers  = new int[6];
         int[] twist    = new int[8];
         int[] perm     = new int[8];
         getCorners(object,corners);
         int result1 = checkAllCornersPresent(corners);
         int result1 = computeFaceColors(corners,mFaceColors);
         if( result1<0 ) return result1;
         mFaceColors = computeFaceColors(corners);
         int result2 = checkAllCornersPresent(corners);
         if( result2<0 ) return result2;
         getCenters(object,centers);
         int result2 = checkAllCentersPresent(centers);
         if( result2<0 ) return result2;
         int result3 = checkAllCentersPresent(centers);
         if( result3<0 ) return result3;
     /*
     for(int i=0; i<8; i++)
       for(int j=0; j<3; j++) android.util.Log.e("D", "corner "+i+" face "+j+" : "+corners[i][j]);
         // TODO...
     for(int i=0; i<6; i++) android.util.Log.e("D", "center "+i+" : "+centers[i]);
     for(int i=0; i<6; i++) android.util.Log.e("D", "face "+i+" : "+mFaceColors[i]);
     */
         if( !TablebaseHelpers.permutationIsEven(centers) ) return ERROR_TWO_CENTERS;
         int center_perm_num = TablebaseHelpers.computeEvenPermutationNum(centers);
         return 0;
         int result4 = retCornerPermutation(perm,corners);
         if( result4<0 ) return result4;
         fillCornerTwists(twist,corners,perm);
     for(int i=0; i<8; i++) android.util.Log.e("D", "perm  "+i+" : "+perm[i]);
     for(int i=0; i<8; i++) android.util.Log.e("D", "twist "+i+" : "+twist[i]);
         int totalTwist = 0;
         for(int i=0; i<8; i++) totalTwist += twist[i];
     android.util.Log.e("D", "total twist "+totalTwist);
         if( (totalTwist%3)!=0 ) return ERROR_CORNER_TWISTED;
         int total = twist[0]+ 3*(twist[1]+ 3*(twist[2]+ 3*(twist[3]+ 3*(twist[4]+ 3*(twist[5]+ 3*twist[6])))));
         int corner1 = positionOfFirstCorner(perm,twist);
         if( corner1<0 ) return ERROR_TWO_CORNERS;
     android.util.Log.e("D", "corner1:  "+corner1+" center perm: "+center_perm_num+" twist: "+total);
         return corner1 + 4*(center_perm_num + 360*total);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision cff92952

Added by Leszek Koltunski almost 2 years ago