Magic Cube

import android.content.res.Resources;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

        OperatingSystemInterface os = act.getInterface();

        Resources res = act.getResources();

        SolvingThread solver = new SolvingThread( os,res,object,list );

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

// Copyright 2024 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.objectlib.algsolvers.SolutionListener;

import org.distorted.objectlib.algsolvers.SolvedObject;

import org.distorted.objectlib.algsolvers.implemented.PhasedSolver3x3Beginner;

import org.distorted.objectlib.algsolvers.implemented.PhasedSolverAbstract;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.solverui.ScreenList;

import org.distorted.solverui.ScreenPhasedSolution;

import org.distorted.solverui.ScreenSolver;

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

public abstract class SolverAlgorithmic implements SolvingInterface, SolutionListener

{

  private final SolvedObject mSolvedObject;

  private final PhasedSolverAbstract mSolver;

  private final OperatingSystemInterface mOS;

  private final Resources mRes;

  private final TwistyObject mObject;

  private long mTime;

  private ScreenSolver mScreen;

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

// PUBLIC API

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

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

    {

    mOS     = os;

    mRes    = res;

    mObject = object;

    mSolver = new PhasedSolver3x3Beginner();

    mSolvedObject = mSolver.getObject();

    }

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

  abstract int[] validatePosition(TwistyObject object);

  abstract String getError(Resources res);

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

  public void solve(ScreenSolver screen)

    {

    mScreen = screen;

    int[] quats = validatePosition(mObject);

    if( quats!=null )

      {

      int numPhases = mSolver.getNumPhases();

      String[] names = new String[numPhases];

      for(int p=0; p<numPhases; p++) names[p] = mSolver.getPhaseName(p);

      ScreenPhasedSolution solScreen = (ScreenPhasedSolution) ScreenList.PHAS.getScreenClass();

      solScreen.updateNames(names);

      mTime = System.currentTimeMillis();

      mSolver.solution(this,quats);

      }

    else

      {

      String error = getError(mRes);

      screen.displayImpossibleDialog(error);

      }

    }

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

  public void receiveSolution(int[] solution, int phaseNumber)

    {

    if( solution==null )

      {

      String message = "Phase "+phaseNumber+": FAIL";

      System.out.println(message);

      }

    else

      {

      int numMoves = solution[0];

      int[][] moves = new int[numMoves][];

      int index = 0;

      for(int m=1; m<=numMoves; m++)

        moves[index++] = mSolvedObject.findMove(solution[m]);

      int[][] subphases = mSolver.getSubPhases(phaseNumber);

      mScreen.setSolved(moves,phaseNumber,subphases);

      }

    long time = System.currentTimeMillis();

    long diff = time - mTime;

    mTime = time;

    System.out.println("Phase "+phaseNumber+" solved in "+diff+"ms. Moves: "+(solution==null ? 0:solution[0]));

    }

}  

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

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

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.solverui.SolverActivity;

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

public class SolverAlgorithmicCUBE3 extends SolverAlgorithmic

{

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

    {

    super(os,res,object);

    }

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

  int[] validatePosition(TwistyObject object)

    {

    int numCubits = object.getNumCubits();

    int[] ret = new int[numCubits];   // mockup

    return ret;

    }

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

  String getError(Resources res)

    {

    return null;

    }

}  

  CUBE2          (CUBE_2.ordinal(), SolverTablebaseCUBE2.class  , R.string.solver_cube2_title, R.string.solver_cube2_description, true),

  CUBE3_KOCIEMBA (CUBE_3.ordinal(), SolverKociembaCUBE3.class   , R.string.solver_cube3_title, R.string.solver_cube3_description, true),

  CUBE3_ALGO     (CUBE_3.ordinal(), SolverAlgorithmicCUBE3.class, R.string.solver_3algo_title, R.string.solver_3algo_description, true),

  CU232          (CU_232.ordinal(), SolverTablebaseCU232.class  , R.string.solver_cu232_title, R.string.solver_cu232_description, true),

  CU323          (CU_323.ordinal(), SolverTablebaseCU323.class  , R.string.solver_cu323_title, R.string.solver_cu323_description, true),

  PYRAMINX       (PYRA_3.ordinal(), SolverTablebasePYRA3.class  , R.string.solver_pyra3_title, R.string.solver_pyra3_description, true),

  SKEWB          (SKEW_2.ordinal(), SolverTablebaseSKEW2.class  , R.string.solver_skew2_title, R.string.solver_skew2_description, true),

  PYRAMINX_DUO   (PDUO_2.ordinal(), SolverTablebasePDUO2.class  , R.string.solver_pduo2_title, R.string.solver_pduo2_description, true),

  IVY            (IVY_2.ordinal() , SolverTablebaseIVY2.class   , R.string.solver_ivy_title, R.string.solver_ivy_description, true),

  DIAMOND        (DIAM_2.ordinal(), SolverTablebaseDIAM2.class  , R.string.solver_diam2_title, R.string.solver_diam2_description, true),

  JING2          (JING_2.ordinal(), SolverTablebaseJING2.class  , R.string.solver_jing2_title, R.string.solver_jing2_description, true),

  DINO6          (DINO_3.ordinal(), SolverTablebaseDINO6.class  , R.string.solver_dino6_title, R.string.solver_dino6_description, true),

  DINO4          (DIN4_3.ordinal(), SolverTablebaseDINO4.class  , R.string.solver_dino4_title, R.string.solver_dino4_description, true),

  PDIA           (PDIA_3.ordinal(), SolverTablebasePDIA3.class  , R.string.solver_pdia_title, R.string.solver_pdia_description, true),

  SVER ( null , MODE_REPLACE, new ScreenSolver()         ),

  SOLU ( SVER , MODE_DRAG   , new ScreenSolution()       ),

  PHAS ( SVER , MODE_DRAG   , new ScreenPhasedSolution() ),

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

// Copyright 2024 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.solverui;

import android.content.SharedPreferences;

import android.util.TypedValue;

import android.view.Gravity;

import android.view.View;

import android.widget.LinearLayout;

import android.widget.TextView;

import org.distorted.helpers.TransparentImageButton;

import org.distorted.library.effect.PostprocessEffectGlow;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Dynamic2D;

import org.distorted.library.type.Dynamic4D;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static4D;

import org.distorted.main.R;

import org.distorted.objectlib.helpers.MovesFinished;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.TwistyObject;

import java.lang.ref.WeakReference;

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

public class ScreenPhasedSolution extends ScreenAbstract implements MovesFinished, EffectListener

  {

  private static final int MOVES_PLACE_0 = 100;

  private static final int MOVES_PLACE_1 = 101;

  private static final int FLASH_TIME = 1200;

  private static final int MILLIS_PER_DEGREE = 6;

  private WeakReference<SolverActivity> mAct;

  private TransparentImageButton mPrevButton, mNextButton, mBackButton, mPrevPhase, mNextPhase;

  private float mButtonSize;

  private TextView mMovesText, mMovesPhase;

  private String[] mPhaseNames;

  private int mNumPhases;

  private int[][][] mMoves;

  private int[][] mCubitsNotInvolved;

  private int mNumMoves,mCurrMove,mCurrPhase;

  private boolean mCanMove;

  private Dynamic2D mHaloAndRadiusDyn;

  private Dynamic4D mColorDyn;

  private PostprocessEffectGlow mGlow;

  private boolean mEffectWorking;

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

  void leaveScreen(SolverActivity act)

    {

    ObjectControl control = act.getControl();

    control.solveOnly();

    }

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

  void enterScreen(final SolverActivity act)

    {

    mAct = new WeakReference<>(act);

    mHaloAndRadiusDyn = new Dynamic2D(FLASH_TIME,1.0f);

    mHaloAndRadiusDyn.add(new Static2D( 0,0));

    mHaloAndRadiusDyn.add(new Static2D(10,5));

    mColorDyn = new Dynamic4D(FLASH_TIME,1.0f);

    final int[] colors  = new int[] {1,1,1}; // white

    Static4D P1 = new Static4D(colors[0],colors[1],colors[2], 0.0f);

    Static4D P2 = new Static4D(colors[0],colors[1],colors[2], 1.0f);

    mColorDyn.add(P1);

    mColorDyn.add(P2);

    mGlow = new PostprocessEffectGlow(mHaloAndRadiusDyn,mColorDyn);

    float width = act.getScreenWidthInPixels();

    mButtonSize = width*SolverActivity.BUTTON_TEXT_SIZE;

    // TOP ////////////////////////////

    LinearLayout layoutTop = act.findViewById(R.id.upperBar);

    layoutTop.removeAllViews();

    setupPrevPhase(act);

    setupNextPhase(act);

    setupTextPhase(act,width);

    layoutTop.addView(mPrevPhase);

    layoutTop.addView(mMovesPhase);

    layoutTop.addView(mNextPhase);

    // BOT ////////////////////////////

    LinearLayout layoutBot = act.findViewById(R.id.lowerBar);

    layoutBot.removeAllViews();

    LinearLayout.LayoutParams paramsL = new LinearLayout.LayoutParams((int)(width/2),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout.LayoutParams paramsM = new LinearLayout.LayoutParams((int)(width/6),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout.LayoutParams paramsR = new LinearLayout.LayoutParams((int)(width/3),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout layoutLeft = new LinearLayout(act);

    layoutLeft.setLayoutParams(paramsL);

    LinearLayout layoutMid = new LinearLayout(act);

    layoutMid.setLayoutParams(paramsM);

    LinearLayout layoutRight = new LinearLayout(act);

    layoutRight.setLayoutParams(paramsR);

    setupPrevButton(act);

    setupNextButton(act);

    setupTextView(act,width);

    layoutLeft.addView(mPrevButton);

    layoutLeft.addView(mMovesText);

    layoutLeft.addView(mNextButton);

    setupBackButton(act);

    layoutRight.addView(mBackButton);

    layoutBot.addView(layoutLeft);

    layoutBot.addView(layoutMid);

    layoutBot.addView(layoutRight);

    }

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

  private void setupPrevButton(final SolverActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(0,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mPrevButton = new TransparentImageButton(act,R.drawable.ui_left,params);

    mPrevButton.setOnClickListener( new View.OnClickListener()

      {

      @Override public void onClick(View v) { backMove(); }

      });

    }

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

  private void setupNextButton(final SolverActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(0,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mNextButton = new TransparentImageButton(act,R.drawable.ui_right,params);

    mNextButton.setOnClickListener( new View.OnClickListener()

      {

      @Override public void onClick(View v) { nextMove(); }

      });

    }

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

  private void setupTextView(final SolverActivity act, final float width)

    {

    int padding = (int)(width*SolverActivity.PADDING);

    int margin  = (int)(width*SolverActivity.SMALL_MARGIN);

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(0,LinearLayout.LayoutParams.MATCH_PARENT,2.0f);

    params.topMargin    = margin;

    params.bottomMargin = margin;

    params.leftMargin   = margin;

    params.rightMargin  = margin;

    mMovesText = new TextView(act);

    mMovesText.setTextSize(20);

    mMovesText.setLayoutParams(params);

    mMovesText.setPadding(padding,0,padding,0);

    mMovesText.setGravity(Gravity.CENTER);

    mMovesText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mButtonSize);

    mMovesText.setText(act.getString(R.string.mo_placeholder,mCurrMove,mNumMoves));

    }

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

  private void setupPrevPhase(final SolverActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(0,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mPrevPhase = new TransparentImageButton(act,R.drawable.ui_left,params);

    mPrevPhase.setOnClickListener( new View.OnClickListener()

      {

      @Override public void onClick(View v) { backPhase(); }

      });

    }

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

  private void setupNextPhase(final SolverActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(0,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mNextPhase = new TransparentImageButton(act,R.drawable.ui_right,params);

    mNextPhase.setOnClickListener( new View.OnClickListener()

      {

      @Override public void onClick(View v) { nextPhase(); }

      });

    }

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

  private void setupTextPhase(final SolverActivity act, final float width)

    {

    int padding = (int)(width*SolverActivity.PADDING);

    int margin  = (int)(width*SolverActivity.SMALL_MARGIN);

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(0,LinearLayout.LayoutParams.MATCH_PARENT,2.0f);

    params.topMargin    = margin;

    params.bottomMargin = margin;

    params.leftMargin   = margin;

    params.rightMargin  = margin;

    mMovesPhase = new TextView(act);

    mMovesPhase.setTextSize(20);

    mMovesPhase.setLayoutParams(params);

    mMovesPhase.setPadding(padding,0,padding,0);

    mMovesPhase.setGravity(Gravity.CENTER);

    mMovesPhase.setTextSize(TypedValue.COMPLEX_UNIT_PX, mButtonSize);

    mMovesPhase.setText(act.getString(R.string.mo_placeholder,mCurrMove,mNumMoves));

    }

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

  private void setupBackButton(final SolverActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mBackButton = new TransparentImageButton(act,R.drawable.ui_back,params);

    mBackButton.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        ScreenList.goBack(act);

        }

      });

    }

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

  public void savePreferences(SharedPreferences.Editor editor) { }

  public void restorePreferences(SharedPreferences preferences) { }

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

  void backPhase()

    {

    SolverActivity act = mAct.get();

    ObjectControl control = act.getControl();

    if( mCurrMove>0 )

      {

      int[][] moves = transformMoves(mMoves[mCurrPhase],0,mCurrMove, false);

      control.applyScrambles(moves);

      mCurrMove = 0;

      }

    else if( mCurrPhase>0 )

      {

      mCurrPhase--;

      mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

      mCurrMove = 0;

      int[][] moves = transformMoves(mMoves[mCurrPhase],0,mNumMoves, false);

      control.applyScrambles(moves);

      }

    else

      {

      mCurrPhase = mNumPhases-1;

      mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

      mCurrMove = mNumMoves;

      int[][] moves = transformMoves(mMoves, true);

      control.applyScrambles(moves);

      }

    setText(act);

    }

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

  void nextPhase()

    {

    SolverActivity act = mAct.get();

    ObjectControl control = act.getControl();

    if( mCurrPhase<mNumPhases-1 )

      {

      glowCubits(mCubitsNotInvolved[mCurrPhase]);

      int[][] moves = transformMoves(mMoves[mCurrPhase],mCurrMove,mNumMoves, true);

      control.applyScrambles(moves);

      mCurrPhase++;

      mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

      mCurrMove = 0;

      }

    else if( mCurrMove<mNumMoves )

      {

      glowCubits(mCubitsNotInvolved[mCurrPhase]);

      int[][] moves = transformMoves(mMoves[mCurrPhase],mCurrMove,mNumMoves, true);

      control.applyScrambles(moves);

      mCurrMove = mNumMoves;

      }

    else

      {

      mCurrPhase = 0;

      mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

      mCurrMove = 0;

      int[][] moves = transformMoves(mMoves, false);

      control.applyScrambles(moves);

      }

    setText(act);

    }

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

  private void setText(SolverActivity act)

    {

    int currMove = 0;

    int totalMove = 0;

    if( mMoves!=null )

      {

      currMove = mCurrMove;

      for(int p=0; p<mCurrPhase; p++) currMove  += (mMoves[p]==null ? 0: mMoves[p].length);

      for(int p=0; p<mNumPhases; p++) totalMove += (mMoves[p]==null ? 0: mMoves[p].length);

      }

    final int cMove = currMove;

    final int tMove = totalMove;

    act.runOnUiThread(new Runnable()

      {

      @Override

      public void run()

        {

        mMovesPhase.setText(mPhaseNames[mCurrPhase]+" "+mCurrMove+"/"+mNumMoves);

        mMovesText.setText(cMove+"/"+tMove);

        }

      });

    }

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

  private int[][] transformMoves(int[][] moves, int start, int end, boolean front)

    {

    int mult = front ? 1:-1;

    int len = end-start;

    int[][] ret = new int[len][];

    for(int m=0; m<len; m++)

      {

      int[] mv = moves[front ? start+m : end-1-m];

      int[] rt = new int[3];

      rt[0] = mv[0];

      rt[1] = (1<<mv[1]);

      rt[2] = mult*mv[2];

      ret[m] = rt;

      }

    return ret;

    }

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

  private int[][] transformMoves(int[][][] moves, boolean front)

    {

    int len = moves.length;

    int totalLen = 0;

    for (int[][] move : moves) totalLen += (move==null ? 0 : move.length);

    int[][] ret = new int[totalLen][];

    int mult = front ? 1:-1;

    int index = 0;

    for(int m=0; m<len; m++)

      {

      int[][] mv = moves[front ? m : len-1-m];

      int l = (mv==null ? 0 : mv.length);

      for(int p=0; p<l; p++)

        {

        int[] mve = mv[front ? p : l-1-p];

        int[] rt = new int[3];

        rt[0] = mve[0];

        rt[1] = (1<<mve[1]);

        rt[2] = mult*mve[2];

        ret[index++] = rt;

        }

      }

    return ret;

    }

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

  private void glowCubits(int[] cubits)

    {

    if( !mEffectWorking )

      {

      mEffectWorking = true;

      SolverActivity act=mAct.get();

      ObjectControl control = act.getControl();

      TwistyObject object=control.getObject();

      DistortedEffects effects=object.getObjectEffects();

      effects.apply(mGlow);

      MeshBase mesh=object.getObjectMesh();

      mesh.setComponentsNotAffectedByPostprocessing(cubits);

      mHaloAndRadiusDyn.resetToBeginning();

      mColorDyn.resetToBeginning();

      mGlow.notifyWhenFinished(this);

      }

    }

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

  private int[] computeCubitsNotInvolved(int[][] subphases, int numCubits)

    {

    int numCubitsInvolved = 0;

    boolean[] involved = new boolean[numCubits];

    for(int[] sub : subphases)

      if( sub!=null )

        for(int s : sub)

          {

          numCubitsInvolved++;

          involved[s] = true;

          }

    int[] ret = new int[numCubits-numCubitsInvolved];

    int index = 0;

    for(int c=0; c<numCubits; c++)

      if( !involved[c] ) ret[index++] = c;

    return ret;

    }

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

  void backMove()

    {

    if( mMoves!=null && mCanMove )

      {

      SolverActivity act=mAct.get();

      if( mCurrMove>0 )

        {

        mCanMove = false;

        int[] move = mMoves[mCurrPhase][--mCurrMove];

        ObjectControl control = act.getControl();

        control.blockTouch(MOVES_PLACE_0);

        control.addRotation(this, move[0], (1<<move[1]), -move[2], MILLIS_PER_DEGREE);

        }

      else if( mCurrPhase>0 )

        {

        mCurrPhase--;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = mNumMoves;

        glowCubits(mCubitsNotInvolved[mCurrPhase]);

        }

      else

        {

        mCurrPhase = mNumPhases-1;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = mNumMoves;

        int[][] moves = transformMoves(mMoves, true);

        ObjectControl control = act.getControl();

        control.applyScrambles(moves);

        glowCubits(mCubitsNotInvolved[mCurrPhase]);

        }

      setText(act);

      }

    }

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

  void nextMove()

    {

    if( mMoves!=null && mCanMove )

      {

      SolverActivity act=mAct.get();

      if( mCurrMove<mNumMoves )

        {

        mCanMove = false;

        int[] move = mMoves[mCurrPhase][mCurrMove++];

        ObjectControl control = act.getControl();

        control.blockTouch(MOVES_PLACE_1);

        control.addRotation(this, move[0], (1<<move[1]), move[2], MILLIS_PER_DEGREE);

        if( mCurrMove==mNumMoves && mCurrPhase==mNumPhases-1 ) glowCubits(mCubitsNotInvolved[mCurrPhase]);

        }

      else if( mCurrPhase<mNumPhases-1 )

        {

        mCurrPhase++;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = 0;

        glowCubits(mCubitsNotInvolved[mCurrPhase-1]);

        }

      else

        {

        mCurrPhase = 0;

        mNumMoves = mMoves[mCurrPhase]==null ? 0 : mMoves[mCurrPhase].length;

        mCurrMove = 0;

        int[][] moves = transformMoves(mMoves, false);

        ObjectControl control = act.getControl();

        control.applyScrambles(moves);

        }

      setText(act);

      }

    }

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

  public void updateNames(String[] names)

    {

    mPhaseNames = names;

    mNumPhases = names.length;

    mMoves = new int[mNumPhases][][];

    mCubitsNotInvolved = new int[mNumPhases][];

    mCanMove = true;

    if( mAct!=null ) setSolution(null,0,null);

    }

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

  public void setSolution(int[][] moves, int phase, int[][] subphases)

    {

    SolverActivity act=mAct.get();

    if( subphases!=null )

      {

      ObjectControl control=act.getControl();

      TwistyObject object=control.getObject();

      int numCubits=object.getNumCubits();

      mCubitsNotInvolved[phase]= computeCubitsNotInvolved(subphases, numCubits);

      }

    mMoves[phase] = moves;

    if( phase==0 ) mNumMoves = (moves==null ? 0 : moves.length);

    mCurrPhase = 0;

    mCurrMove = 0;

    setText(act);

    }

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

  public void onActionFinished(final long effectID)

    {

    mCanMove = true;

    SolverActivity act=mAct.get();

    ObjectControl control = act.getControl();

    control.unblockRotation();

    }

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

  public void effectFinished(long id)

    {

    SolverActivity act=mAct.get();

    ObjectControl control = act.getControl();

    TwistyObject object=control.getObject();

    DistortedEffects effects=object.getObjectEffects();

    effects.abortById(id);

    mEffectWorking = false;

    }

  }

import android.content.res.Resources;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

        OperatingSystemInterface os = act.getInterface();

        Resources res = act.getResources();

        SolvingThread solver = new SolvingThread( os,res,object,list );

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

  public void setSolved(final int[][] moves, final int phaseNumber, final int[][] subphases)

    {

    mSolving = false;

    final SolverActivity act = mWeakAct.get();

    if( act!=null )

      {

      act.runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          if( phaseNumber==0 ) ScreenList.switchScreen(act, ScreenList.PHAS);

          ScreenPhasedSolution screen = (ScreenPhasedSolution) ScreenList.PHAS.getScreenClass();

          screen.setSolution(moves, phaseNumber,subphases);

          if( moves!=null && moves.length>0 ) act.doNotShowDialogAnymore();

          }

        });

      }

    }

    <string name="solver_cube3_description">Ein nahezu perfekter, sofortiger, zweiphasiger 3x3-Löser.\nAutor: Herbert Kociemba.</string>

    <string name="solver_3algo_description">Implementierung des Anfängeralgorithmus. 7 Phasen. Erzeugt Lösungen mit etwa 100 Zügen.\nAutor: Leszek Koltunski.</string>

    <string name="solver_3algo_description">Implementación del algoritmo para principiantes. 7 fases. Produce soluciones de aproximadamente 100 movimientos.\nAutor: Leszek Koltunski.</string>

    <string name="solver_cube3_description">Un solveur 3x3 biphasé presque parfait, instantané.\nAuteur: Herbert Kociemba.</string>

    <string name="solver_3algo_description">Mise en œuvre de l\'algorithme pour débutants. 7 phases. Produit des solutions longues d\'environ 100 coups.\nAuteur: Leszek Koltunski.</string>

    <string name="solver_3algo_description">初心者向けアルゴリズムの実装。7 フェーズ。約 100 手の長さのソリューションを生成します。\n著者: Leszek Koltunski.</string>

    <string name="solver_3algo_description">초보자 알고리즘 구현. 7단계. 약 100-이동 길이의 솔루션을 생성합니다.\n작가: Leszek Koltunski.</string>

    <string name="solver_3algo_description">Implementacja algorytmu dla początkujących. 7 faz. Tworzy rozwiązania o długości około 100 ruchów.\nAutor: Leszek Koltunski.</string>

    <string name="solver_3algo_description">Реализация алгоритма для начинающих. 7 фаз. Выдает решения длиной около 100 ходов.\nАвтор: Leszek Koltunski.</string>

    <string name="solver_3algo_description">初学者算法的实现。7 个阶段。产生大约 100 步长的解决方案。\n作者: Leszek Koltunski.</string>

    <string name="solver_3algo_description">初學者演算法的實作。 7 個階段。產生大約 100 個動作的長解。\n作者: Leszek Koltunski.</string>

    <string name="solver_3algo_title" translatable="false">3x3 Beginner</string>

    <string name="solver_3algo_description">Implementation of the beginner algorithm. 7 phases. Produces about 100 move long solutions.\nAuthor: Leszek Koltunski.</string>