/ - Diff - Phased Solver - Distorted Android

     import android.content.SharedPreferences;
     import android.os.Bundle;
     import android.view.View;
     import android.widget.TextView;
     import android.widget.Toast;
     import androidx.preference.PreferenceManager;
-...
       private InitAssets mAsset;
       private SharedPreferences mPreferences;
       private SolverLowerPane mLowerPane;
       private TextView mText;
       private SolvedObject mObject;
       private int[][] mMoveTable;
       private String mMoves;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       @Override
-...
         OSInterface os = view.getInterface();
         mAsset = new InitAssets(null, null, os);
         mLowerPane = new SolverLowerPane(this);
         mText = findViewById(R.id.solverMoves);
         mMoves = "";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void solve(PhasedSolver ps, int[] quats, int[][] moveTable)
       private void solve(PhasedSolver ps, int[] quats)
+        {
         int[][] sol = ps.solution(quats);
         int numPhases = sol.length;
-...
           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]);
             moves[index++] = mMoveTable[mi];
             android.util.Log.e("D","move "+m+" : "+mMoveTable[mi][0]+" "+mMoveTable[mi][1]+" "+mMoveTable[mi][2]);
+            }
+          }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void Solve(View v)
         private void createObject()
+          {
           TwistyObject object = getControl().getObject();
-...
           boolean[] r = {true,false,true};
           boolean[][] rot = {r,r,r};//object.getLayerRotatable(numL);
           SolvedObject so = new SolvedObject(pos,axis,angles,cuts,rot);
           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[][] moves = so.getMoveTable();
           int[][] whiteCross   = new int[][]{ {12,13,16,17} };
           int[][] whiteCorners = new int[][]{ {0},{1},{2},{3} };
           int[][] secondLayer  = new int[][]{ {8},{9},{10},{11} };
-...
           Phase[] phases =
+                  {
                     new PhaseNotCyclic( so, whiteCross),
                     new PhaseNotCyclic( so, whiteCorners),
                     new PhaseNotCyclic( so, secondLayer),
                     new PhaseCyclicOrie1( so, yellowCrossCubit , yellowCrossQuat ),
                     new PhaseCyclicPerm2( so, yellowCrossCubit , yellowCrossQuat ),
                     new PhaseRegex( so, regex, yellowCorners ),
                     new PhaseNotCyclic( mObject, whiteCross),
                     new PhaseNotCyclic( mObject, whiteCorners),
                     new PhaseNotCyclic( mObject, secondLayer),
                     new PhaseCyclicOrie1( mObject, yellowCrossCubit , yellowCrossQuat ),
                     new PhaseCyclicPerm2( mObject, yellowCrossCubit , yellowCrossQuat ),
                     new PhaseRegex( mObject, regex, yellowCorners ),
                   };
           PhasedSolver ps = new PhasedSolver(so,phases);
           PhasedSolver ps = new PhasedSolver(mObject,phases);
           runOnUiThread(new Runnable()
+            {
             @Override
             public void run()
+              {
               solve(ps,qi,moves);
               solve(ps,qi);
+              }
             });
+          }
-...
           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);
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     import org.distorted.objectlib.helpers.ObjectLibInterface;
     import java.lang.ref.WeakReference;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     public class SolverObjectLibInterface implements ObjectLibInterface
+    {
       private final WeakReference<SolverActivity> mAct;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       SolverObjectLibInterface(SolverActivity act) { mAct = new WeakReference<>(act); }
       public void onWinEffectFinished(long startTime, long endTime, String debug, int scrambleNum) { }
       public void onScrambleEffectFinished() { }
       public void onBeginRotation() { }
       public void onSolved() { }
       public void onObjectCreated(long time) { }
       public void onRemoveRotation(int axis, int row, int angle) { }
       public void failedToDrag() { }
       public void reportBlockProblem(int type, int place, long pause, long resume, long time) { }
       public void reportProblem(String problem, boolean reportException) {}
       public void onReplaceModeDown(int cubit, int face) { }
       public void onReplaceModeUp() { }
       public void reportJSONError(String error, int ordinal) { }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void onRemoveRotation(int axis, int row, int angle)
+        {
         SolverActivity act = mAct.get();
         act.addMove(axis,row,angle);
+        }
+    }

           if(!isInEditMode())
+            {
             SolverActivity act = (SolverActivity)context;
             SolverObjectLibInterface ref = new SolverObjectLibInterface();
             SolverObjectLibInterface ref = new SolverObjectLibInterface(act);
             mInterface = new OSInterface(act,ref);
             mObjectController = new ObjectControl(mInterface);

         </LinearLayout>
         <TextView
             android:id="@+id/solverMoves"
             android:layout_below="@id/upperBar"
             android:layout_width="match_parent"
             android:layout_height="60dp"
             android:textAppearance="?android:attr/textAppearanceLarge"
             android:gravity="center_vertical|start"/>
         <LinearLayout
             android:id="@+id/lowerBar"
             android:layout_alignParentBottom="true"

Project

General

Profile

Phased Solver

Revision eb0369a7

Added by Leszek Koltunski about 1 year ago