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 static org.distorted.objectlib.main.TwistyObject.MODE_NORM;

import android.app.Activity;

import android.content.SharedPreferences;

import android.os.Bundle;

import android.view.View;

import android.widget.TextView;

import android.widget.Toast;

import androidx.preference.PreferenceManager;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.algsolvers.PhaseMitm;

import org.distorted.objectlib.algsolvers.*;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.metadata.ListObjects;

import org.distorted.os.OSInterface;

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

public class SolverActivity extends Activity

{

  private InitAssets mAsset;

  private SharedPreferences mPreferences;

  private SolverLowerPane mLowerPane;

  private TextView mText;

  private SolvedObject mObject;

  private int[][] mMoveTable;

  private String mMoves;

  private int mNumMoves;

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

  @Override

  protected void onCreate(Bundle icicle)

    {

    super.onCreate(icicle);

    mPreferences = PreferenceManager.getDefaultSharedPreferences(this);

    DistortedLibrary.onCreate();

    setContentView(R.layout.mainlayout);

    SolverSurfaceView view = findViewById(R.id.solverView);

    OSInterface os = view.getInterface();

    mAsset = new InitAssets(null, null, os);

    mLowerPane = new SolverLowerPane(this);

    mText = findViewById(R.id.solverMoves);

    mMoves = "";

    mNumMoves = 0;

    }

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

  @Override

  protected void onPause()

    {

    super.onPause();

    SolverSurfaceView view = findViewById(R.id.solverView);

    view.onPause();

    DistortedLibrary.onPause();

    savePreferences();

    }

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

  @Override

  protected void onResume()

    {

    super.onResume();

    SolverSurfaceView view = findViewById(R.id.solverView);

    view.onResume();

    DistortedLibrary.onResume();

    restorePreferences();

    ObjectControl control = getControl();

    control.changeObject(ListObjects.CUBE_3.ordinal(), MODE_NORM, mAsset);

    }

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

  @Override

  protected void onDestroy()

    {

    DistortedLibrary.onDestroy();

    super.onDestroy();

    }

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

  ObjectControl getControl()

    {

    SolverSurfaceView view = findViewById(R.id.solverView);

    return view.getObjectControl();

    }

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

  private void savePreferences()

    {

    SharedPreferences.Editor editor = mPreferences.edit();

    SolverSurfaceView view = findViewById(R.id.solverView);

    OSInterface os = view.getInterface();

    os.setEditor(editor);

    view.getObjectControl().savePreferences();

    editor.apply();

    }

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

  private void restorePreferences()

    {

    SolverSurfaceView view = findViewById(R.id.solverView);

    OSInterface os = view.getInterface();

    os.setPreferences(mPreferences);

    view.getObjectControl().restorePreferences();

    }

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

  private void solve(SolverPhased ps, int[] quats)

    {

    int[][] sol = ps.solution(quats);

    int numPhases = sol.length;

    int totalLength = 0;

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

      {

      int numMoves = sol[p]==null ? -1 : sol[p][0];

      if( numMoves<0 )

        {

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

        Toast.makeText(this,message,Toast.LENGTH_LONG).show();

        return;

        }

      totalLength += numMoves;

      }

    int[][] moves = new int[totalLength][];

    int index = 0;

    for( int[] s : sol )

      {

      int numMoves = s[0];

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

        {

        int mi = s[m];

        moves[index++] = mMoveTable[mi];

       // android.util.Log.e("D","move "+m+" : "+mMoveTable[mi][0]+" "+mMoveTable[mi][1]+" "+mMoveTable[mi][2]);

        }

      }

    mLowerPane.setMoves(this,moves);

    }

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

    private void createObject()

      {

      TwistyObject object = getControl().getObject();

      int[] numL      = object.getNumLayers();

      float[][] pos   = object.getCubitPositions(numL);

      Static3D[] axis = object.getRotationAxis();

      int[][] angles  = object.getBasicAngles();

      float[][] cuts  = object.getCuts(numL);

      boolean[] r = {true,false,true};

      boolean[][] rot = {r,r,r};//object.getLayerRotatable(numL);

      mObject = new SolvedObject(pos,axis,angles,cuts,rot);

      mMoveTable = mObject.getMoveTable();

      }

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

    public void Solve(View v)

      {

      if( mObject==null ) createObject();

      TwistyObject object = getControl().getObject();

      int[] numL      = object.getNumLayers();

      float[][] pos   = object.getCubitPositions(numL);

      int numCubits = pos.length;

      int[] qi = new int[numCubits];

      for(int i=0; i<numCubits; i++) qi[i] = object.getCubitQuatIndex(i);

      int[][] whiteCross   = new int[][]{ {12,13,16,17} };

      int[][] whiteCorners = new int[][]{ {0},{1},{2},{3} };

      int[][] secondLayer  = new int[][]{ {8},{9},{10},{11} };

      int[][] algsSecondL  = { { 6, 3, 8, 3,15, 5,17}, {15, 5,17, 5, 6, 3, 8},

                               {12, 3,14, 3, 8, 5, 6}, { 8, 5, 6, 5,12, 3,14},

                               {11, 3, 9, 3,14, 5,12}, {14, 5,12, 5,11, 3, 9},

                               {17, 3,15, 3, 9, 5,11}, { 9, 5,11, 5,17, 3,15},

                               {3}

                             };

      int[][] algsEdgeOrie = { {11,17,5,15,3,9},{3} };

      int[][] algsEdgePerm = { {6,5,8,5,6,4,8},{3} };

      int[][] algsCornPerm = { {5,6,3,9,5,8,3,11},{3} };

      int[][] algsCornOrie = { {15,2,17,0,15,2,17,0},{3} };

      int[][] moveTable = mObject.getMoveTable();

      MoveProviderAll  all = new MoveProviderAll(moveTable);

      MoveProviderAlgs asl = new MoveProviderAlgs(algsSecondL);

      MoveProviderAlgs aeO = new MoveProviderAlgs(algsEdgeOrie);

      MoveProviderAlgs aeP = new MoveProviderAlgs(algsEdgePerm);

      MoveProviderAlgs acP = new MoveProviderAlgs(algsCornPerm);

      MoveProviderAlgs acO = new MoveProviderAlgs(algsCornOrie);

      TargetProvider wcr = new TargetProviderAll(whiteCross);

      TargetProvider wco = new TargetProviderAll(whiteCorners);

      TargetProvider sla = new TargetProviderAll(secondLayer);

      TargetProvider oll = new TargetProviderOrie(mObject,14,1);

      TargetProvider pll = new TargetProviderPerm(mObject,14,1);

      TargetProvider pcl = new TargetProviderPerm(mObject, 4,1);

      TargetProvider ocl = new TargetProviderOrie(mObject, 4,1);

      Phase[] phases =

              {

                new PhaseMitm( mObject, all, wcr),

                new PhaseMitm( mObject, all, wco),

                new PhaseMitm( mObject, asl, sla),

                new PhaseMitm( mObject, aeO, oll),

                new PhaseMitm( mObject, aeP, pll),

                new PhaseMitm( mObject, acP, pcl),

                new PhaseMitm( mObject, acO, ocl),

              };

      SolverPhased ps = new SolverPhased(mObject,phases);

      runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          solve(ps,qi);

          }

        });

      }

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

    public void Reset(View v)

      {

      ObjectControl control = getControl();

      control.solveObject();

      mLowerPane.clearMoves(this);

      mNumMoves = 0;

      mMoves = "";

      mText.setText(mMoves);

      }

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

    int findMove(int ax, int row, int angle)

      {

      int num = mMoveTable.length;

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

        {

        int[] move = mMoveTable[m];

        if( ax==move[0] && row==move[1] && angle==move[2] ) return m;

        }

      return -1;

      }

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

    void addMove(int axis, int row, int angle)

      {

      if( mObject==null ) createObject();

      int move = findMove(axis,row,angle);

      mMoves += (" "+move);

      mNumMoves++;

      if( mNumMoves>10 )

        {

        int space = mMoves.indexOf(' ');

        mMoves = mMoves.substring(space+2);

        mNumMoves--;

        }

      mText.setText(mMoves);

      }

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

    public void Left(View v)

      {

      mLowerPane.backMove(this);

      }

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

    public void Right(View v)

      {

      mLowerPane.makeMove(this);

      }

}