Phased Solver

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

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

import android.widget.TextView;

import org.distorted.objectlib.helpers.MovesFinished;

import org.distorted.objectlib.main.ObjectControl;

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

public class SolverLowerPane implements MovesFinished

{

  private static final int MOVES_PLACE_0 = 100;

  private static final int MOVES_PLACE_1 = 101;

  private static final int MILLIS_PER_DEGREE = 6;

  private final String[] mPhaseNames;

  private final TextView mText, mPhase;

  private int[][][] mMoves;

  private int mNumMoves,mCurrMove;

  private int mNumPhases,mCurrPhase;

  private boolean mCanMove;

  private ObjectControl mControl;

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

  SolverLowerPane(SolverActivity act, String[] names)

    {

    mText  = act.findViewById(R.id.solverText);

    mPhase = act.findViewById(R.id.solverPhaseName);

    mPhaseNames = names;

    mNumPhases = names.length;

    mCanMove = true;

    setMoves(act,null);

    }

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

  void backPhase(SolverActivity act)

    {

    if( mCurrMove>0 )

      {

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

      mControl = act.getControl();

      mControl.applyScrambles(moves);

      mCurrMove = 0;

      }

    else if( mCurrPhase>0 )

      {

      mCurrPhase--;

      mNumMoves = mMoves[mCurrPhase].length;

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

      mControl = act.getControl();

      mControl.applyScrambles(moves);

      }

    else

      {

      mCurrPhase = mNumPhases-1;

      mNumMoves = mMoves[mCurrPhase].length;

      mCurrMove = mNumMoves;

      mControl = act.getControl();

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

      mControl.applyScrambles(moves);

      }

    setText(act);

    }

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

  void nextPhase(SolverActivity act)

    {

    if( mCurrMove<mNumMoves )

      {

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

      mCurrMove = mNumMoves;

      mControl = act.getControl();

      mControl.applyScrambles(moves);

      }

    else if( mCurrPhase<mNumPhases-1 )

      {

      mCurrPhase++;

      mNumMoves = mMoves[mCurrPhase].length;

      mCurrMove = mNumMoves;

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

      mControl = act.getControl();

      mControl.applyScrambles(moves);

      }

    else

      {

      mCurrPhase = 0;

      mNumMoves = mMoves[mCurrPhase].length;

      mCurrMove = 0;

      mControl = act.getControl();

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

      mControl.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()

        {

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

        mText.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;

    }

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

  void setMoves(SolverActivity act, int[][][] moves)

    {

    mMoves    = moves;

    mCurrPhase= 0;

    mNumMoves = moves==null || moves[0]==null ? 0 : moves[0].length;

    mCurrMove = 0;

    setText(act);

    }

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

  void clearMoves(SolverActivity act)

    {

    setMoves(act,null);

    }

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

  void backMove(SolverActivity act)

    {

    if( mMoves!=null && mCanMove )

      {

      if( mCurrMove>0 )

        {

        mCanMove = false;

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

        mControl = act.getControl();

        mControl.blockTouch(MOVES_PLACE_0);

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

        }

      else if( mCurrPhase>0 )

        {

        mCurrPhase--;

        mNumMoves = mMoves[mCurrPhase].length;

        mCurrMove = mNumMoves;

        }

      else

        {

        mCurrPhase = mNumPhases-1;

        mNumMoves = mMoves[mCurrPhase].length;

        mCurrMove = mNumMoves;

        mControl = act.getControl();

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

        mControl.applyScrambles(moves);

        }

      setText(act);

      }

    }

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

  void nextMove(SolverActivity act)

    {

    if( mMoves!=null && mCanMove )

      {

      if( mCurrMove<mNumMoves )

        {

        mCanMove = false;

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

        mControl = act.getControl();

        mControl.blockTouch(MOVES_PLACE_1);

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

        }

      else if( mCurrPhase<mNumPhases-1 )

        {

        mCurrPhase++;

        mNumMoves = mMoves[mCurrPhase].length;

        mCurrMove = 0;

        }

      else

        {

        mCurrPhase = 0;

        mNumMoves = mMoves[mCurrPhase].length;

        mCurrMove = 0;

        mControl = act.getControl();

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

        mControl.applyScrambles(moves);

        }

      setText(act);

      }

    }

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

  public void onActionFinished(final long effectID)

    {

    mCanMove = true;

    mControl.unblockRotation();

    }

}