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

import androidx.preference.PreferenceManager;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.algsolvers.PhasedSolver;

import org.distorted.objectlib.algsolvers.SolvedObject;

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;

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

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

    }

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

  @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(PhasedSolver ps, int[] quats, int[][] moveTable)

    {

    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++] = moveTable[mi];

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

        }

      }

    mLowerPane.setMoves(this,moves);

    }

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

    public void Solve(View v)

      {

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

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

      int numCubits = pos.length;

      int[] qi = new int[numCubits];

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

      int[][] moves = so.getMoveTable();

      int[][] params = { {12,13,16,17},{0,1,2,3} };

      int[] modes  = { PhasedSolver.MODE_ALL_AT_ONCE_OP, PhasedSolver.MODE_ONE_BY_ONE_OP };

      PhasedSolver ps = new PhasedSolver(so,params,modes);

      runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          solve(ps,qi,moves);

          }

        });

      }

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

    public void Reset(View v)

      {

      ObjectControl control = getControl();

      control.solveObject();

      mLowerPane.clearMoves(this);

      }

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

    public void Left(View v)

      {

      mLowerPane.backMove(this);

      }

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

    public void Right(View v)

      {

      mLowerPane.makeMove(this);

      }

}