Magic Cube

import org.distorted.solvers.pduo.SolverPyraminxDuo;

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.solvers.pduo;

import android.content.res.Resources;

import org.distorted.main.R;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.solvers.SolverTablebase;

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

public class SolverPyraminxDuo extends SolverTablebase

{

  private static final int ERROR_CORNER_GYB_MISSING = -1;

  private static final int ERROR_CORNER_GYR_MISSING = -2;

  private static final int ERROR_CORNER_GBR_MISSING = -3;

  private static final int ERROR_CORNER_YBR_MISSING = -4;

  private static final int ERROR_CENTER_G_MISSING = -5;

  private static final int ERROR_CENTER_Y_MISSING = -6;

  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_CORNER_TWISTED   = -10;

  private static final int ERROR_CORNERS_CANNOT   = -11;

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

  private boolean cornerEqual(int[] corner, int c1, int c2, int c3)

    {

    return ( (corner[0]==c1 && corner[1]==c2 && corner[2]==c3) ||

             (corner[0]==c1 && corner[2]==c2 && corner[1]==c3) ||

             (corner[1]==c1 && corner[0]==c2 && corner[2]==c3) ||

             (corner[1]==c1 && corner[2]==c2 && corner[0]==c3) ||

             (corner[2]==c1 && corner[1]==c2 && corner[0]==c3) ||

             (corner[2]==c1 && corner[0]==c2 && corner[1]==c3)  );

    }

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

  private int checkAllCornersPresent(int[][] corners)

    {

    boolean ybr = false;

    boolean gbr = false;

    boolean gyr = false;

    boolean gyb = false;

    for(int i=0; i<4; i++)

      {

      if( cornerEqual(corners[i],0,1,2) ) gyb = true;

      if( cornerEqual(corners[i],0,1,3) ) gyr = true;

      if( cornerEqual(corners[i],0,2,3) ) gbr = true;

      if( cornerEqual(corners[i],1,2,3) ) ybr = true;

      }

    if( !ybr ) return ERROR_CORNER_YBR_MISSING;

    if( !gbr ) return ERROR_CORNER_GBR_MISSING;

    if( !gyr ) return ERROR_CORNER_GYR_MISSING;

    if( !gyb ) return ERROR_CORNER_GYB_MISSING;

    return 0;

    }

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

  private int checkAllCentersPresent(int[] centers)

    {

    if( centers[0]!=0 && centers[1]!=0 && centers[2]!=0 && centers[3]!=0 ) return ERROR_CENTER_G_MISSING;

    if( centers[0]!=1 && centers[1]!=1 && centers[2]!=1 && centers[3]!=1 ) return ERROR_CENTER_Y_MISSING;

    if( centers[0]!=2 && centers[1]!=2 && centers[2]!=2 && centers[3]!=2 ) return ERROR_CENTER_B_MISSING;

    if( centers[0]!=3 && centers[1]!=3 && centers[2]!=3 && centers[3]!=3 ) return ERROR_CENTER_R_MISSING;

    return 0;

    }

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

  private int getFaceOfGreenCenter(int[] centers)

    {

    if( centers[0]==0 ) return 0;

    if( centers[1]==0 ) return 1;

    if( centers[2]==0 ) return 2;

    if( centers[3]==0 ) return 3;

    return -1;

    }

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

  private int[] computeMissingCornerColor(int[][] corners)

    {

    int[] ret = new int[4];

    for(int i=0; i<4; i++)

      for(int j=0; j<4; j++)

        if( corners[i][0]!=j && corners[i][1]!=j && corners[i][2]!=j ) ret[i]=j;

    return ret;

    }

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

  private int computeCornerTwist(int index, int[] corner, int[] missing)

    {

    int twist1=0, twist2=0, twist3=0;

    switch(index)

      {

      case 0: if( corner[1]==missing[1] ) twist1=1;

              if( corner[2]==missing[1] ) twist1=2;

              if( corner[0]==missing[2] ) twist2=2;

              if( corner[2]==missing[2] ) twist2=1;

              if( corner[0]==missing[3] ) twist3=1;

              if( corner[1]==missing[3] ) twist3=2;

              break;

      case 1: if( corner[1]==missing[0] ) twist1=1;

              if( corner[2]==missing[0] ) twist1=2;

              if( corner[0]==missing[2] ) twist2=1;

              if( corner[1]==missing[2] ) twist2=2;

              if( corner[0]==missing[3] ) twist3=2;

              if( corner[2]==missing[3] ) twist3=1;

              break;

      case 2: if( corner[1]==missing[0] ) twist1=1;

              if( corner[2]==missing[0] ) twist1=2;

              if( corner[0]==missing[1] ) twist2=2;

              if( corner[2]==missing[1] ) twist2=1;

              if( corner[0]==missing[3] ) twist3=1;

              if( corner[1]==missing[3] ) twist3=2;

              break;

      case 3: if( corner[1]==missing[0] ) twist1=1;

              if( corner[2]==missing[0] ) twist1=2;

              if( corner[0]==missing[1] ) twist2=1;

              if( corner[1]==missing[1] ) twist2=2;

              if( corner[0]==missing[2] ) twist3=2;

              if( corner[2]==missing[2] ) twist3=1;

              break;

      }

    return ( twist1!=twist2 || twist1!=twist3 ) ? ERROR_CORNERS_CANNOT : twist1;

    }

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

  private int computeCenterTwist(int[] centers, int color1, int color2)

    {

    if( centers[0]==color1 )

      {

      if( centers[1]==color2 ) return 1;

      if( centers[2]==color2 ) return 2;

      if( centers[3]==color2 ) return 0;

      return -1;

      }

    if( centers[1]==color1 )

      {

      if( centers[0]==color2 ) return 1;

      if( centers[2]==color2 ) return 0;

      if( centers[3]==color2 ) return 2;

      return -1;

      }

    if( centers[2]==color1 )

      {

      if( centers[0]==color2 ) return 2;

      if( centers[1]==color2 ) return 0;

      if( centers[3]==color2 ) return 1;

      return -1;

      }

    if( centers[3]==color1 )

      {

      if( centers[0]==color2 ) return 0;

      if( centers[1]==color2 ) return 2;

      if( centers[2]==color2 ) return 1;

      return -1;

      }

    return -2;

    }

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

  public SolverPyraminxDuo(Resources res, TwistyObject object)

    {

    super(res,object);

    }

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

  public int tablebaseIndex(TwistyObject object)

    {

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

    int[] centers = new int[4];

    int[] corner_twist = new int[4];

    for(int i=0; i<4; i++)

      {

      centers[i] = object.getCubitFaceStickerIndex(i+4,0) - 4;

      for(int j=0; j<3; j++)

        corners[i][j] = object.getCubitFaceStickerIndex(i,j);

      }

    int result1 = checkAllCornersPresent(corners);

    if( result1<0 ) return result1;

    int result2 = checkAllCentersPresent(centers);

    if( result2<0 ) return result2;

    int twist_gr = computeCenterTwist(centers,0,3);

    int twist_ry = computeCenterTwist(centers,3,1);

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

    int total_twist=0;

    int[] missing = computeMissingCornerColor(corners);

    for(int i=0; i<4; i++)

      {

      corner_twist[i] = computeCornerTwist(i,corners[i],missing);

      if( corner_twist[i]<0 ) return corner_twist[i];

      total_twist += corner_twist[i];

      }

    if( (total_twist-twist_gr)%3 !=0 ) return ERROR_CORNER_TWISTED;

    int green_face = getFaceOfGreenCenter(centers);

    return green_face + 4*(corner_twist[3] + 3*(corner_twist[2] + 3*(corner_twist[1] + 3*corner_twist[0])));

    }

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

  public String error(int index, Resources res)

    {

    switch(index)

      {

      case ERROR_CORNER_YBR_MISSING: String c01 = res.getString(R.string.color_yellow3);

                                     String c02 = res.getString(R.string.color_blue3);

                                     String c03 = res.getString(R.string.color_red4);

                                     return res.getString(R.string.solver_generic_missing_corner,c01,c02,c03);

      case ERROR_CORNER_GBR_MISSING: String c11 = res.getString(R.string.color_green3);

                                     String c12 = res.getString(R.string.color_blue3);

                                     String c13 = res.getString(R.string.color_red4);

                                     return res.getString(R.string.solver_generic_missing_corner,c11,c12,c13);

      case ERROR_CORNER_GYR_MISSING: String c21 = res.getString(R.string.color_green3);

                                     String c22 = res.getString(R.string.color_yellow3);

                                     String c23 = res.getString(R.string.color_red4);

                                     return res.getString(R.string.solver_generic_missing_corner,c21,c22,c23);

      case ERROR_CORNER_GYB_MISSING: String c31 = res.getString(R.string.color_green3);

                                     String c32 = res.getString(R.string.color_yellow3);

                                     String c33 = res.getString(R.string.color_blue4);

                                     return res.getString(R.string.solver_generic_missing_corner,c31,c32,c33);

      case ERROR_CENTER_G_MISSING  : String colorG = res.getString(R.string.color_green2);

                                     return res.getString(R.string.solver_generic_missing_center,colorG);

      case ERROR_CENTER_Y_MISSING  : String colorY = res.getString(R.string.color_yellow2);

                                     return res.getString(R.string.solver_generic_missing_center,colorY);

      case ERROR_CENTER_B_MISSING  : String colorB = res.getString(R.string.color_blue2);

                                     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_CORNER_TWISTED    : return res.getString(R.string.solver_generic_corner_twist);

      case ERROR_CORNERS_CANNOT    : return res.getString(R.string.solver_generic_corners_cannot);

      }

    return null;

    }

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

  public String solution(int index, Resources res)

    {

    return "";

    }

}  

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.solvers.pduo;

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

public class TablebasesPyraminxDuo

{

}