Magic Cube

  private void getCorners(TwistyObject object, int[][] corners)

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int tablebaseIndex(TwistyObject object)

    {

    int[][] corners= new int[8][3];

    getCorners(object,corners);

  private static final int ERROR_TWO_CENTERS      = -9;

    if( (twist_ry-twist_gr+1)%3 != 0 ) return ERROR_TWO_CENTERS;

      case ERROR_TWO_CENTERS       : return res.getString(R.string.solver_generic_two_centers);

import org.distorted.objectlib.tablebases.TablebaseHelpers;

  private static final int ERROR_IMPOSSIBLE         = -19;

  private final int[] mFaceColors;

    mFaceColors = new int[6];

    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 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;

      }

  private boolean cornerIs(int[] corner, int c0, int c1, int c2)

    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 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;

    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;

///////////////////////////////////////////////////////////////////////////////////////////////////

  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;

    }

    int[][] corners= new int[8][3];

    int[] centers  = new int[6];

    int[] twist    = new int[8];

    int[] perm     = new int[8];

    int result1 = computeFaceColors(corners,mFaceColors);

    int result2 = checkAllCornersPresent(corners);

    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]);

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);

    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);