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;

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

  @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 = "";

    }

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

  @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[][] yellowEdges  = new int[][]{ {14,15,18,19} };

      String lleoA = "(11,17,5,15,3,9)";

      String lleoB = "(17,6,5,8,3,15)";

      String lleoC = "(6,12,5,14,3,8)";

      String lleoD = "(12,11,5,9,3,14)";

      String llEdgesOrie = lleoA+"{0,1,2} "+lleoB+"{0,1,2} "+lleoC+"{0,1,2} "+lleoD+"{0,1,2}";

      String llepA = "(6,5,8,5,6,4,8)";

      String llepB = "(12,5,14,5,12,4,14)";

      String llepC = "(11,5,9,5,11,4,9)";

      String llEdgesPerm = "(3){0,1} ["+llepA+"{-1,0,1};"+llepB+"] "+llepC+"{-1,0,1}";

      String llEdges = llEdgesOrie+" "+llEdgesPerm;

      int[][] yellowCorners= new int[][]{ {4,5,6,7} };

      String llcpA = "(5,6,3,9,5,8,3,11)";

      String llcpB = "(5,12,3,15,5,14,3,17)";

      String llcpC = "(5,11,3,8,5,9,3,6)";

      String llCornersPerm = "["+llcpA+"{-1,0,1};"+llcpB+"] "+llcpC+"{-1,0,1}";

      String llco  = "(3,8,5,6){-2,0,2} (11)";

      String llCornersOrie = llco+" "+llco+" "+llco+" "+llco;

      String llCorners = llCornersPerm+" "+llCornersOrie;

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

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

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

      MoveProviderAll  all = new MoveProviderAll(moveTable);

      MoveProviderAlgs alO = new MoveProviderAlgs(algsOrie);

      MoveProviderAlgs alP = new MoveProviderAlgs(algsPerm);

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

      Phase[] phases =

              {

                new PhaseMitm( mObject, all, wcr),

                new PhaseMitm( mObject, all, wco),

                new PhaseMitm( mObject, all, sla),

                new PhaseMitm( mObject, alO, oll),

                new PhaseMitm( mObject, alP, pll),

              };

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

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

      mText.setText(mMoves);

      }

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

    public void Left(View v)

      {

      mLowerPane.backMove(this);

      }

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

    public void Right(View v)

      {

      mLowerPane.makeMove(this);

      }

}