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.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.objectlib.helpers.MovesFinished;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.TwistyObject;

import java.lang.ref.WeakReference;

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

public class SolverLowerPane implements MovesFinished, EffectListener

{

  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 static final int FLASH_TIME = 1200;

  private final TextView mText, mPhase;

  private String[] mPhaseNames;

  private int mNumPhases;

  private int[][][] mMoves;

  private int[][] mCubitsNotInvolved;

  private int mNumMoves,mCurrMove,mCurrPhase;

  private boolean mCanMove;

  private final Dynamic2D mHaloAndRadiusDyn;

  private final Dynamic4D mColorDyn;

  private final PostprocessEffectGlow mGlow;

  private final WeakReference<SolverActivity> mAct;

  private boolean mEffectWorking;

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

  SolverLowerPane(SolverActivity act, String[] names)

    {

    mAct = new WeakReference<>(act);

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

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

    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);

    mPhaseNames = names;

    mNumPhases = names.length;

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

    mCubitsNotInvolved = new int[mNumPhases][];

    mCanMove = true;

    setSolution(null,0,null);

    }

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

  void updateNames(String[] names)

    {

    mPhaseNames = names;

    mNumPhases = names.length;

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

    mCubitsNotInvolved = new int[mNumPhases][];

    mCanMove = true;

    setSolution(null,0,null);

    }

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

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

        {

        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;

    }

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

  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);

      }

    }

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

  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;

    }

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

  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 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);

    }

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

  void clearMoves()

    {

    for(int p=0; p<mNumPhases; p++) mMoves[p] = null;

    mNumMoves = 0;

    mCurrPhase= 0;

    mCurrMove = 0;

    setText(mAct.get());

    }

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

  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 onActionFinished(final long effectID)

    {

    mCanMove = true;

    SolverActivity act=mAct.get();

    ObjectControl control = act.getControl();

    control.unblockRotation();

    }

}