/ - Diff - Phased Solver - Distorted Android

« Previous | Next »

Revision 4d2a5fd3

Added by Leszek Koltunski 3 months ago

ID 4d2a5fd3b9593fcfb30cb1ba9486066c471735bb
Parent 2c567b1f
Child 78843d15

Improve the Phased Solver App (show phases)

         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;
         mBeginner = new Solver3x3Beginner();
         mObject = mBeginner.getObject();
         int numPhases = mBeginner.getNumPhases();
         String[] names = new String[numPhases];
         for(int p=0; p<numPhases; p++) names[p] = mBeginner.getPhaseName(p);
         mLowerPane = new SolverLowerPane(this,names);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         super.onDestroy();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void Left(View v)       { mLowerPane.backMove(this); }
       public void Right(View v)      { mLowerPane.nextMove(this); }
       public void PhaseLeft(View v)  { mLowerPane.backPhase(this); }
       public void PhaseRight(View v) { mLowerPane.nextPhase(this); }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       ObjectControl getControl()
-...
+        {
         int[][] sol = mBeginner.solution(quats);
         int numPhases = sol.length;
         int totalLength = 0;
         for(int p=0; p<numPhases; p++)
+          {
-...
+            {
             String message = "Phase "+p+": FAIL";
             Toast.makeText(this,message,Toast.LENGTH_LONG).show();
             return;
             break;
+            }
           totalLength += numMoves;
+          }
         int[][] moves = new int[totalLength][];
         int index = 0;
         int[][][] moves = new int[numPhases][][];
         for( int[] s : sol )
         for( int p=0; p<numPhases; p++ )
+          {
           int numMoves = s[0];
           int numMoves = sol[p][0];
           moves[p] = new int[numMoves][];
           int index = 0;
           for(int m=1; m<=numMoves; m++)
+            {
             int mi = s[m];
             moves[index++] = mObject.findMove(mi);
             int mi = sol[p][m];
             moves[p][index++] = mObject.findMove(mi);
+            }
+          }
-...
           mText.setText(mMoves);
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void Left(View v)
+          {
           mLowerPane.backMove(this);
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void Right(View v)
+          {
           mLowerPane.makeMove(this);
+          }
+    }

       private static final int MOVES_PLACE_1 = 101;
       private static final int MILLIS_PER_DEGREE = 6;
       private int[][] mMoves;
       private int mNumMoves;
       private int mCurrMove;
       private final String[] mPhaseNames;
       private final TextView mText, mPhase;
       private int[][][] mMoves;
       private int mNumMoves,mCurrMove;
       private int mNumPhases,mCurrPhase;
       private boolean mCanMove;
       private final TextView mText;
       private ObjectControl mControl;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       SolverLowerPane(SolverActivity act)
       SolverLowerPane(SolverActivity act, String[] names)
+        {
         mText = act.findViewById(R.id.solverText);
         mText  = act.findViewById(R.id.solverText);
         mPhase = act.findViewById(R.id.solverPhaseName);
         mPhaseNames = names;
         mNumPhases = names.length;
         mCanMove = true;
         setMoves(act,null);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void backPhase(SolverActivity act)
+        {
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void nextPhase(SolverActivity act)
+        {
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void setText(SolverActivity act)
-...
           @Override
           public void run()
+            {
             mPhase.setText(mPhaseNames[mCurrPhase]);
             mText.setText(mCurrMove+"/"+mNumMoves);
+            }
           });
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int[][] transformMoves(int[][] moves, boolean back)
       private int[][] transformMoves(int[][][] moves, boolean front)
+        {
         int len = moves.length;
         int[][] ret = new int[len][];
         int mult = back ? 1:-1;
         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[back ? m : len-1-m];
           int[] rt = new int[3];
           int[][] mv = moves[front ? m : len-1-m];
           int l = (mv==null ? 0 : mv.length);
           rt[0] = mv[0];
           rt[1] = (1<<mv[1]);
           rt[2] = mult*mv[2];
           ret[m] = rt;
           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;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void setMoves(SolverActivity act, int[][] moves)
       void setMoves(SolverActivity act, int[][][] moves)
+        {
         mMoves    = moves;
         mNumMoves = moves==null ? 0 : moves.length;
         mCurrMove = moves==null ?-1 : 0;
         mCurrPhase= 0;
         mNumMoves = moves==null || moves[0]==null ? 0 : moves[0].length;
         mCurrMove = 0;
         setText(act);
+        }
-...
           if( mCurrMove>0 )
+            {
             mCanMove = false;
             int[] move = mMoves[--mCurrMove];
             int[] move = mMoves[mCurrPhase][--mCurrMove];
             mControl = act.getControl();
             mControl.blockTouch(MOVES_PLACE_0);
             mControl.addRotation(this, move[0], (1<<move[1]), -move[2], MILLIS_PER_DEGREE);
+            }
           else if( mCurrPhase>0 )
+            {
             mCurrPhase--;
             mNumMoves = mMoves[mCurrPhase].length;
             mCurrMove = mNumMoves;
+            }
           else
+            {
             mCurrPhase = mNumPhases-1;
             mNumMoves = mMoves[mCurrPhase].length;
             mCurrMove = mNumMoves;
             mControl = act.getControl();
             int[][] moves = transformMoves(mMoves,true);
             int[][] moves = transformMoves(mMoves, true);
             mControl.applyScrambles(moves);
+            }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void makeMove(SolverActivity act)
       void nextMove(SolverActivity act)
+        {
         if( mMoves!=null && mCanMove )
+          {
           if( mCurrMove<mNumMoves )
+            {
             mCanMove = false;
             int[] move = mMoves[mCurrMove++];
             int[] move = mMoves[mCurrPhase][mCurrMove++];
             mControl = act.getControl();
             mControl.blockTouch(MOVES_PLACE_1);
             mControl.addRotation(this, move[0], (1<<move[1]), move[2], MILLIS_PER_DEGREE);
+            }
           else if( mCurrPhase<mNumPhases-1 )
+            {
             mCurrPhase++;
             mNumMoves = mMoves[mCurrPhase].length;
             mCurrMove = 0;
+            }
           else
+            {
             mCurrPhase = 0;
             mNumMoves = mMoves[mCurrPhase].length;
             mCurrMove = 0;
             mControl = act.getControl();
             int[][] moves = transformMoves(mMoves,false);
             int[][] moves = transformMoves(mMoves, false);
             mControl.applyScrambles(moves);
+            }

             android:id="@+id/solverMoves"
             android:layout_below="@id/upperBar"
             android:layout_width="match_parent"
             android:layout_height="60dp"
             android:layout_height="50dp"
             android:background="@color/white"
             android:textColor="@color/black"
             android:layout_marginStart="4dp"
             android:layout_marginEnd="4dp"
             android:textAppearance="?android:attr/textAppearanceLarge"
             android:gravity="center_vertical|start"/>
-...
                 android:onClick="Left"
                 android:layout_gravity="center_vertical"/>
             <TextView
                 android:id="@+id/solverText"
             <LinearLayout
                 android:layout_width="0dp"
                 android:layout_height="match_parent"
                 android:layout_weight="5.0"
                 android:gravity="center"
                 android:textSize="40sp"/>
                 android:orientation="vertical"
                 android:background="@android:color/transparent">
                 <TextView
                     android:id="@+id/solverPhaseName"
                     android:layout_width="match_parent"
                     android:layout_height="0dp"
                     android:layout_weight="1"
                     android:gravity="center"
                     android:textSize="20sp"/>
                 <TextView
                     android:id="@+id/solverText"
                     android:layout_width="match_parent"
                     android:layout_height="0dp"
                     android:layout_weight="2"
                     android:gravity="center"
                     android:textSize="30sp"/>
             </LinearLayout>
             <ImageButton
                 android:id="@+id/solverRight"

Also available in: Unified diff

Project

General

Profile

Phased Solver

Revision 4d2a5fd3

Added by Leszek Koltunski 3 months ago