Magic Cube

  DINO4          (ObjectSignatures.DIN4_3, R.string.solver_dino4_title, R.string.solver_dino4_description, true),

  PDIA           (ObjectSignatures.PDIA_3, R.string.solver_pdia_title, R.string.solver_pdia_description, true),

    else if( mSignature==ObjectSignatures.PDIA_3 )

      {

      SolverTablebase solver = new SolverPyraminxDiamond(mRes,mObject);

      solver.solve(screen);

      }

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

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

import android.content.res.Resources;

import org.distorted.main.R;

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;

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

public class SolverPyraminxDiamond extends SolverTablebase

{

  private static final int ERROR_CORNER_FR_MISSING = -1;

  private static final int ERROR_CORNER_BR_MISSING = -2;

  private static final int ERROR_CORNER_BL_MISSING = -3;

  private static final int ERROR_CORNER_FL_MISSING = -4;

  private static final int ERROR_CORNER_TO_MISSING = -5;

  private static final int ERROR_CORNER_BO_MISSING = -6;

  private static final int ERROR_CENTER_0_MISSING = -7;

  private static final int ERROR_CENTER_1_MISSING = -8;

  private static final int ERROR_CENTER_2_MISSING = -9;

  private static final int ERROR_CENTER_3_MISSING = -10;

  private static final int ERROR_CENTER_4_MISSING = -11;

  private static final int ERROR_CENTER_5_MISSING = -12;

  private static final int ERROR_CENTER_6_MISSING = -13;

  private static final int ERROR_CENTER_7_MISSING = -14;

  private static final int ERROR_TWO_CENTERS      = -15;

  private static final int ERROR_CORNERS_CANNOT   = -16;

  private TablebasesAbstract mSolver;

  private final int[] mFaceColors;

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

  public SolverPyraminxDiamond(Resources res, TwistyObject object)

    {

    super(res,object);

    mFaceColors = new int[8];

    }

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

  private int retCenter(int color, int[] centers)

    {

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

      if( centers[i]==color ) return i;

    return -1;

    }

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

  private int[] getCentersPermutation(int[] centers)

    {

    int[] perm = new int[8];

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

      perm[i] = retCenter(mFaceColors[i],centers);

    return perm;

    }

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

  private boolean isTwistEven(int[] twist)

    {

    int total = twist[0]+twist[1]+twist[2]+twist[3]+twist[4]+twist[5];

    return ((total%2)==0);

    }

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

  private int indexOf(int[] corner, int color )

    {

    if( corner[0]==color ) return 0;

    if( corner[1]==color ) return 1;

    if( corner[2]==color ) return 2;

    if( corner[3]==color ) return 3;

    return -1;

    }

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

  private int[] getCornersTwist(int[][] corners)

    {

    int[] twist = new int[6];

    twist[0] = indexOf(corners[0],mFaceColors[0]);

    twist[1] = indexOf(corners[1],mFaceColors[5]);

    twist[2] = indexOf(corners[2],mFaceColors[2]);

    twist[3] = indexOf(corners[3],mFaceColors[4]);

    twist[4] = indexOf(corners[4],mFaceColors[2]);

    twist[5] = indexOf(corners[5],mFaceColors[6]);

    return twist;

    }

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

  private int checkAllColorsDifferent()

    {

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

      {

      boolean present = false;

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

        if( mFaceColors[j]==i )

          {

          present=true;

          break;

          }

      if( !present ) return ERROR_CORNERS_CANNOT;

      }

    return 0;

    }

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

  private int checkAllCentersPresent(int[] centers)

    {

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

      {

      boolean present = false;

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

        if( centers[j]==i )

          {

          present=true;

          break;

          }

      if( !present )

        {

        switch(i)

          {

          case 0: return ERROR_CENTER_0_MISSING;

          case 1: return ERROR_CENTER_1_MISSING;

          case 2: return ERROR_CENTER_2_MISSING;

          case 3: return ERROR_CENTER_3_MISSING;

          case 4: return ERROR_CENTER_4_MISSING;

          case 5: return ERROR_CENTER_5_MISSING;

          case 6: return ERROR_CENTER_6_MISSING;

          case 7: return ERROR_CENTER_7_MISSING;

          }

        }

      }

    return 0;

    }

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

  private int commonColor(int[][] corners, int index1, int index2, int index3)

    {

    int[] c1 = corners[index1];

    int[] c2 = corners[index2];

    int[] c3 = corners[index3];

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

      {

      int c = c1[i];

      if( (c2[0]==c || c2[1]==c || c2[2]==c || c2[3]==c) &&

          (c3[0]==c || c3[1]==c || c3[2]==c || c3[3]==c)  ) return c;

      }

    return ERROR_CORNERS_CANNOT;

    }

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

  private int figureOutFaceColors(int[] output, int[][] corners)

    {

    int[][] commonCorners = {{0,2,4},{0,3,5},{1,2,4},{1,3,5},{0,2,3},{1,2,3},{0,4,5},{1,4,5}};

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

      {

      int[] common = commonCorners[i];

      output[i] = commonColor(corners,common[0],common[1],common[2]);

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

      }

    return 0;

    }

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

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

    {

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

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

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

    }

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

  private void getCenters(TwistyObject object, int[] centers)

    {

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

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

    }

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

  public int tablebaseIndex(TwistyObject object)

    {

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

    int[] centers = new int[8];

    getCorners(object,corners);

    getCenters(object,centers);

    int result1 = figureOutFaceColors(mFaceColors,corners);

    if( result1<0 ) return result1;

    int result2 = checkAllCentersPresent(centers);

    if( result2<0 ) return result2;

    int result3 = checkAllColorsDifferent();

    if( result3<0 ) return result3;

    int[] twist = getCornersTwist(corners);

    boolean even1 = isTwistEven(twist);

    int[] centers_perm = getCentersPermutation(centers);

    boolean even2 = TablebaseHelpers.permutationIsEven(centers_perm);

    if( even1^even2 ) return ERROR_TWO_CENTERS;

    int centers_perm_num = TablebaseHelpers.computePermutationNum(centers_perm);

    int total_twist = twist[0]+ 4*(twist[1]+ 4*(twist[2]+ 4*(twist[3]+ 4*(twist[4]+ 4*(twist[5]>1 ? 0:1)))));

/*

android.util.Log.e("D", "faces: "+mFaceColors[0]+" "+mFaceColors[1]+" "+mFaceColors[2]+" "

+mFaceColors[3]+" "+mFaceColors[4]+" "+mFaceColors[5]+" "+mFaceColors[6]+" "+mFaceColors[7]);

android.util.Log.e("D", "corn twist: "+twist[0]+" "+twist[1]+" "+twist[2]+" "+twist[3]+" "+twist[4]+" "+twist[5]);

android.util.Log.e("D", "ret="+(total_twist + 2048*centers_perm_num) );

*/

    return total_twist + 2048*centers_perm_num;

    }

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

  private int getColorIndex4(int face)

    {

    switch(mFaceColors[face])

      {

      case 0: return R.string.color_violet4;

      case 1: return R.string.color_grey4;

      case 2: return R.string.color_blue4;

      case 3: return R.string.color_red4;

      case 4: return R.string.color_orange4;

      case 5: return R.string.color_green4;

      case 6: return R.string.color_white4;

      case 7: return R.string.color_yellow4;

      }

    return -1;

    }

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

  private int getColorIndex3(int face)

    {

    switch(mFaceColors[face])

      {

      case 0: return R.string.color_violet3;

      case 1: return R.string.color_grey3;

      case 2: return R.string.color_blue3;

      case 3: return R.string.color_red3;

      case 4: return R.string.color_orange3;

      case 5: return R.string.color_green3;

      case 6: return R.string.color_white3;

      case 7: return R.string.color_yellow3;

      }

    return -1;

    }

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

  private int getColorIndex2(int face)

    {

    switch(face)

      {

      case 0: return R.string.color_violet2;

      case 1: return R.string.color_grey2;

      case 2: return R.string.color_blue2;

      case 3: return R.string.color_red2;

      case 4: return R.string.color_orange2;

      case 5: return R.string.color_green2;

      case 6: return R.string.color_white2;

      case 7: return R.string.color_yellow2;

      }

    return -1;

    }

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

  private String centerError(Resources res, int face)

    {

    String color = res.getString(getColorIndex2(face));

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

    }

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

  private String cornerError(Resources res, int f1, int f2)

    {

    String c1 = res.getString(getColorIndex3(f1));

    String c2 = res.getString(getColorIndex4(f2));

    return res.getString(R.string.solver_generic_missing_corner2,c1,c2);

    }

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

  public String error(int index, Resources res)

    {

    switch(index)

      {

      case ERROR_CORNER_FR_MISSING: return cornerError(res,1,4);

      case ERROR_CORNER_BR_MISSING: return cornerError(res,1,6);

      case ERROR_CORNER_BL_MISSING: return cornerError(res,3,6);

      case ERROR_CORNER_FL_MISSING: return cornerError(res,3,4);

      case ERROR_CORNER_TO_MISSING: return cornerError(res,1,3);

      case ERROR_CORNER_BO_MISSING: return cornerError(res,4,6);

      case ERROR_CENTER_0_MISSING : return centerError(res,0);

      case ERROR_CENTER_1_MISSING : return centerError(res,1);

      case ERROR_CENTER_2_MISSING : return centerError(res,2);

      case ERROR_CENTER_3_MISSING : return centerError(res,3);

      case ERROR_CENTER_4_MISSING : return centerError(res,4);

      case ERROR_CENTER_5_MISSING : return centerError(res,5);

      case ERROR_CENTER_6_MISSING : return centerError(res,6);

      case ERROR_CENTER_7_MISSING : return centerError(res,7);

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

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

      }

    return null;

    }

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

  public int[][] solution(int index, Resources res)

    {

    if( mSolver==null )

      {

      mSolver = ImplementedTablebasesList.createUnpacked(ObjectSignatures.PDIA_3);

      if( mSolver!=null )

        {

        mSolver.createTablebase(2);

        }

      }

    return mSolver!=null ? mSolver.solution(index,null) : null;

    }

}