Magic Cube

  JING2          (ObjectSignatures.JING_2, R.string.solver_jing2_title, R.string.solver_jing2_description, true),

    else if( mSignature==ObjectSignatures.SKEW_2 )

      {

      SolverTablebase solver = new SolverSkewb(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.TablebasesAbstract;

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

public class SolverSkewb extends SolverTablebase

{

  private static final int ERROR_CORNER_135_MISSING = -1;

  private static final int ERROR_CORNER_134_MISSING = -2;

  private static final int ERROR_CORNER_125_MISSING = -3;

  private static final int ERROR_CORNER_124_MISSING = -4;

  private static final int ERROR_CORNER_035_MISSING = -5;

  private static final int ERROR_CORNER_034_MISSING = -6;

  private static final int ERROR_CORNER_025_MISSING = -7;

  private static final int ERROR_CORNER_024_MISSING = -8;

  private static final int ERROR_CENTER_0_MISSING   = -9;

  private static final int ERROR_CENTER_1_MISSING   = -10;

  private static final int ERROR_CENTER_2_MISSING   = -11;

  private static final int ERROR_CENTER_3_MISSING   = -12;

  private static final int ERROR_CENTER_4_MISSING   = -13;

  private static final int ERROR_CENTER_5_MISSING   = -14;

  private static final int ERROR_CORNERS_CANNOT     = -15;

  private static final int ERROR_CORNER_TWISTED     = -16;

  private static final int ERROR_TWO_CENTERS        = -17;

  private static final int ERROR_TWO_CORNERS        = -18;

  private TablebasesAbstract mSolver;

  private int[] mFaceColors;

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

  public SolverSkewb(Resources res, TwistyObject object)

    {

    super(res,object);

    }

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

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

    {

    }

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

  private int checkAllCornersPresent(int[][] corners)

    {

    return 0;

    }

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

  private int[] computeFaceColors(int[][] corners)

    {

    return null;

    }

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

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

    {

    }

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

  private int checkAllCentersPresent(int[] centers)

    {

    return 0;

    }

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

  public int tablebaseIndex(TwistyObject object)

    {

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

    int[] centers     = new int[6];

    int[] corner_twist= new int[6];

    getCorners(object,corners);

    int result1 = checkAllCornersPresent(corners);

    if( result1<0 ) return result1;

    mFaceColors = computeFaceColors(corners);

    getCenters(object,centers);

    int result2 = checkAllCentersPresent(centers);

    if( result2<0 ) return result2;

    // TODO...

    return 0;

    }

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

  private int getColorIndex2(int face)

    {

    switch(mFaceColors[face])

      {

      case 0: return R.string.color_yellow2;

      case 1: return R.string.color_white2;

      case 2: return R.string.color_blue2;

      case 3: return R.string.color_green2;

      case 4: return R.string.color_red2;

      case 5: return R.string.color_orange2;

      }

    return -1;

    }

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

  private int getColorIndex3(int face)

    {

    switch(mFaceColors[face])

      {

      case 0: return R.string.color_yellow3;

      case 1: return R.string.color_white3;

      case 2: return R.string.color_blue3;

      case 3: return R.string.color_green3;

      case 4: return R.string.color_red3;

      case 5: return R.string.color_orange3;

      }

    return -1;

    }

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

  private int getColorIndex4(int face)

    {

    switch(mFaceColors[face])

      {

      case 0: return R.string.color_yellow4;

      case 1: return R.string.color_white4;

      case 2: return R.string.color_blue4;

      case 3: return R.string.color_green4;

      case 4: return R.string.color_red4;

      case 5: return R.string.color_orange4;

      }

    return -1;

    }

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

  private String cornerError(Resources res, int face0, int face1, int face2)

    {

    int j0 = getColorIndex3(face0);

    int j1 = getColorIndex3(face1);

    int j2 = getColorIndex4(face2);

    String c0 = res.getString(j0);

    String c1 = res.getString(j1);

    String c2 = res.getString(j2);

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

    }

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

  private String centerError(Resources res, int face)

    {

    int color = getColorIndex2(face);

    String clr= res.getString(color);

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

    }

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

  public String error(int index, Resources res)

    {

    switch(index)

      {

      case ERROR_CORNER_135_MISSING: return cornerError(res,1,3,5);

      case ERROR_CORNER_134_MISSING: return cornerError(res,1,3,4);

      case ERROR_CORNER_125_MISSING: return cornerError(res,1,2,5);

      case ERROR_CORNER_124_MISSING: return cornerError(res,1,2,4);

      case ERROR_CORNER_035_MISSING: return cornerError(res,0,3,5);

      case ERROR_CORNER_034_MISSING: return cornerError(res,0,3,4);

      case ERROR_CORNER_025_MISSING: return cornerError(res,0,2,5);

      case ERROR_CORNER_024_MISSING: return cornerError(res,0,2,4);

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

      case ERROR_CORNER_TWISTED    : return res.getString(R.string.solver_generic_corner_twist);

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

      case ERROR_TWO_CORNERS       : return res.getString(R.string.solver_generic_two_corners);

      }

    return null;

    }

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

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

    {

    if( mSolver==null )

      {

      mSolver = ImplementedTablebasesList.createUnpacked(ObjectSignatures.SKEW_2);

      if( mSolver!=null )

        {

        mSolver.createTablebase(-1);

        mSolver.pack();

        }

      }

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

    }

}