Magic Cube

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

// 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.helpers.OperatingSystemInterface;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.tablebases.TablebaseHelpers;

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

public class SolverTablebasePDIA3 extends SolverTablebase

{

  private static final int ERROR_CENTER_MISSING = -1;

  private static final int ERROR_TWO_CENTERS    = -2;

  private static final int ERROR_CORNERS_CANNOT = -3;

  private final int[] mFaceColors;

  private int mErrColor;

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

  public SolverTablebasePDIA3(OperatingSystemInterface os, Resources res, TwistyObject object)

    {

    super(os,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 ) { mErrColor=i; return ERROR_CENTER_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 ? 1:0)))));

/*

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 String centerError(Resources res, int face)

    {

    int index = getOctColor(face,2);

    String color = res.getString(index);

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

    }

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

  public String error(int index, Resources res)

    {

    switch(index)

      {

      case ERROR_CENTER_MISSING : return centerError(res,mErrColor);

      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;

    }

}