Magic Cube

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

// Copyright 2020 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.solvers;

import org.distorted.objects.RubikObjectList;

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

public enum ImplementedSolversList

{

  CUBE3 ( RubikObjectList.CUBE, 3),

  ;

  public static final int NUM_OBJECTS = values().length;

  private final RubikObjectList mObject;

  private final int mObjectSize;

  private static final ImplementedSolversList[] objects;

  static

    {

    objects = new ImplementedSolversList[NUM_OBJECTS];

    int i=0;

    for(ImplementedSolversList object: ImplementedSolversList.values())

      {

      objects[i++] = object;

      }

    }

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

  public static RubikObjectList getObject(int ordinal)

    {

    return objects[ordinal].mObject;

    }

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

  public static int getObjectSize(int ordinal)

    {

    return objects[ordinal].mObjectSize;

    }

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

  ImplementedSolversList( RubikObjectList object, int size)

    {

    mObject     = object;

    mObjectSize =  size;

    }

}

import org.distorted.objects.RubikObjectList;

  private Resources mRes;

  private RubikObjectList mObject;

  private int mSize;

  public Solver(Resources res, RubikObjectList object, int size, String position )

    mRes            = res;

    mObject         = object;

    mSize           = size;

  private void solveCube3(RubikStateSolver solver)

    String result;

    if( !org.distorted.solvers.cube3.Search.prepare(mRes) )

      result= "Error 9";

    else

      result = org.distorted.solvers.cube3.Search.solution(mObjectPosition, 24, 20);

    if (result.contains("Error"))

      {

      switch (result.charAt(result.length() - 1))

        {

        case '1': result = mRes.getString(R.string.solver_cube3_error1); break;

        case '2': result = mRes.getString(R.string.solver_cube3_error2); break;

        case '3': result = mRes.getString(R.string.solver_cube3_error3); break;

        case '4': result = mRes.getString(R.string.solver_cube3_error4); break;

        case '5': result = mRes.getString(R.string.solver_cube3_error5); break;

        case '6': result = mRes.getString(R.string.solver_cube3_error6); break;

        case '7': result = mRes.getString(R.string.solver_cube3_error7); break;

        case '8': result = mRes.getString(R.string.solver_cube3_error8); break;

        case '9': result = mRes.getString(R.string.solver_cube3_error9); break;

        }

      solver.displayErrorDialog(result);

      }

    else

      {

      solver.setSolved(result);

      }

  private void interruptCube3()

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

  public void start()

    {

    Thread thr = new Thread(this);

    thr.start();

    }

    if( mObject == RubikObjectList.CUBE && mSize == 3)

      solveCube3(solver);

      solver.displayErrorDialog(mRes.getString(R.string.solver_generic_error1));

  void setupMoves(final RubikActivity act, String moves)

    mNumMoves = moves.length()/4;

    RubikPattern.parseMoves(mMoves,mNumMoves,moves);

import org.distorted.solvers.ImplementedSolversList;

import java.lang.ref.WeakReference;

  private RubikObjectList mCurrentObject;

  private int mCurrentObjectSize;

  private WeakReference<RubikActivity> mWeakAct;

    mWeakAct = new WeakReference<>(act);

    mCurrentObject     = ImplementedSolversList.getObject(0);

    mCurrentObjectSize = ImplementedSolversList.getObjectSize(0);

    act.changeObject(mCurrentObject, mCurrentObjectSize, null);

    play.setObjectAndSize(mCurrentObject, mCurrentObjectSize);

    mFaceColors = RubikObjectList.retFaceColors(mCurrentObject);

          Solver solver = new Solver( act.getResources(), mCurrentObject, mCurrentObjectSize, objectString );

  public void setSolved(final String moves)

    final RubikActivity act = mWeakAct.get();

    if( act!=null )

      act.runOnUiThread(new Runnable()

        @Override

        public void run()

          {

          RubikState.switchState(act,RubikState.SOLU);

          RubikStateSolution solution = (RubikStateSolution) RubikState.SOLU.getStateClass();

          solution.setupMoves(act, moves);

          }

        });

      }

  public void displayErrorDialog( String message)

    RubikActivity act = mWeakAct.get();

    if( act!=null )

      {

      RubikDialogSolverError dialog = new RubikDialogSolverError();

      Bundle bundle = new Bundle();

      bundle.putString("error", message );

      dialog.setArguments(bundle);

      dialog.show( act.getSupportFragmentManager(), null);

      }

    <string name="solver_generic_error1">Solver for this object and size not implemented yet!</string>

    <string name="solver_cube3_error1">There are not exactly 9 facelets of each color!</string>

    <string name="solver_cube3_error2">Not all 12 edges exist exactly once!</string>

    <string name="solver_cube3_error3">One edge has to be flipped!</string>

    <string name="solver_cube3_error4">Not all 8 corners exist exactly once!</string>

    <string name="solver_cube3_error5">One corner has to be twisted!</string>

    <string name="solver_cube3_error6">Two corners or two edges have to be exchanged!</string>

    <string name="solver_cube3_error7">No solution exists for the given maximum move number!</string>

    <string name="solver_cube3_error8">Timeout, no solution found in 20 seconds!</string>

    <string name="solver_cube3_error9">Solver interrupted!</string>