/ - Diff - TwistyPuzzleLib - Distorted Android

« Previous | Next »

Revision baf80e60

Added by Leszek Koltunski 9 months ago

ID baf80e60fc088cae20e10ec267558c2821798840
Parent ea164b48
Child 3fda3a94

ObjectMove

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Copyright 2025 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.objectlib.helpers;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     public class ObjectMove
+      {
       private int axis;
       private int rowBitmap;
       private int row;
       private int angle;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public ObjectMove(int ax, int rb, int ang)
+        {
         axis = ax;
         rowBitmap = rb;
         angle = ang;
         row = makeRowFromBitmap(rb);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void set(ObjectMove move)
+        {
         axis      = move.axis;
         rowBitmap = move.rowBitmap;
         angle     = move.angle;
         row       = move.row;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void set(int ax, int rb, int ang)
+        {
         axis      = ax;
         rowBitmap = rb;
         angle     = ang;
         row = makeRowFromBitmap(rb);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getAxis()      { return axis; }
       public int getRowBitmap() { return rowBitmap; }
       public int getRow()       { return row; }
       public int getAngle()     { return angle; }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int makeRowFromBitmap(int bitmap)
+        {
         for( int ret=0; ret<32; ret++ )
           if( (bitmap&(1<<ret)) != 0 ) return ret;
         return -1;
+        }
+      }

     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.helpers.ObjectMove;
     import org.distorted.objectlib.helpers.OperatingSystemInterface;
     import org.distorted.objectlib.json.JsonReader;
     import org.distorted.objectlib.metadata.Metadata;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void randomizeNewScramble(int[][] scramble, Random rnd, int curr, int total)
       public void randomizeNewScramble(ObjectMove[] moves, Random rnd, int curr, int total)
+        {
         mScrambler.randomizeNewScramble(scramble,rnd,curr,total, getSignature() );
         mScrambler.randomizeNewScramble(moves,rnd,curr,total, getSignature() );
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     import java.util.ArrayList;
     import java.util.Random;
     import org.distorted.objectlib.helpers.ObjectMove;
     import org.distorted.objectlib.signature.ObjectSignature;
     import org.distorted.objectlib.solvers.tablebases.TablebasesAbstract;
-...
       private final int mType;
       private final int mNumAxis;
       private final int[] mNumL;  // this is not exactly the same as mNumLayers - counterexample: shape-shifting cuboids.
       private final int[][] mAlgorithms;
       private final ObjectMove[][] mAlgorithms;
       // type=0, i.e. main
       private int mCurrState;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public ObjectScrambler(int type, int numAxis, int[] numL, int[][] algorithms, int[][] edges, TablebasesAbstract tablebase)
       public ObjectScrambler(int type, int numAxis, int[] numL, ObjectMove[][] algorithms, int[][] edges, TablebasesAbstract tablebase)
+        {
         mType       = type;
         mNumAxis    = numAxis;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
       private void randomizeNewScramble0(int[][] scramble, Random rnd, int curr)
       private void randomizeNewScramble0(ObjectMove[] scramble, Random rnd, int curr)
+        {
         if( curr==0 )
+          {
-...
           initializeScrambling();
+          }
         if( mCurrStep+6 <= mAlgorithms[mCurrAlgorithm].length )
         if( mCurrStep+1 < mAlgorithms[mCurrAlgorithm].length )
+          {
           mCurrStep += 3;
           mCurrStep++;
+          }
         else
+          {
-...
           mCurrStep      = 0;
+          }
         int[] algorithm = mAlgorithms[mCurrAlgorithm];
         scramble[curr][0] = algorithm[mCurrStep  ];
         scramble[curr][1] = algorithm[mCurrStep+1];
         scramble[curr][2] = algorithm[mCurrStep+2];
         mAxisExcluded = algorithm[0];
         ObjectMove algorithm = mAlgorithms[mCurrAlgorithm][mCurrStep];
         scramble[curr].set(algorithm);
         mAxisExcluded = algorithm.getAxis();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TYPE 1
       private void updateCornerQuats(int[] rotInfo)
       private void updateCornerQuats(int axis, int row, int angle)
+        {
         if( mQuatMult==null ) initializeQuatMult();
         int axis = rotInfo[0];
         int layer= rotInfo[1];
         int index=-rotInfo[2];
         int quat = makeQuat(axis,index);
         int quat = makeQuat(axis,-angle);
         for(int corner=0; corner<8; corner++)
+          {
           if( cornerBelongs(corner,axis,layer) )
           if( cornerBelongs(corner,axis,row) )
+            {
             int curr = mCornerQuat[corner];
             mCornerQuat[corner] = mQuatMult[quat][curr];
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TYPE 1
       private void randomizeNewScramble1(int[][] scramble, Random rnd, int curr)
       private void randomizeNewScramble1(ObjectMove[] scramble, Random rnd, int curr)
+        {
         int layer, nextAngle;
-...
                           nextAngle = getNextAngleNotZero(rnd,layer);
+                          }
                         scramble[curr][0] = 0;
                         scramble[curr][1] = 2*layer;
                         scramble[curr][2] = nextAngle;
                         mLastRot = layer==0 ? LAST_LO : LAST_UP;
                         updateCornerQuats(scramble[curr]);
                         scramble[curr][1] = (1<<scramble[curr][1]);
                         int axis1 = 0;
                         int row1  = 2*layer;
                         int angle1= nextAngle;
                         mLastRot  = layer==0 ? LAST_LO : LAST_UP;
                         updateCornerQuats(axis1,row1,angle1);
                         scramble[curr].set(axis1, 1<<row1, angle1);
                         break;
           case LAST_LO:
           case LAST_UP: layer = mLastRot==LAST_LO ? 1:0;
-...
                         if( nextAngle!=0 )
+                          {
                           scramble[curr][0] = 0;
                           scramble[curr][1] = 2*layer;
                           scramble[curr][2] = nextAngle;
                           updateCornerQuats(scramble[curr]);
                           scramble[curr][1] = (1<<scramble[curr][1]);
                           int axis2 = 0;
                           int row2  = 2*layer;
                           int angle2= nextAngle;
                           updateCornerQuats(axis2,row2,angle2);
                           scramble[curr].set(axis2, 1<<row2, angle2);
                           mLastRot = LAST_UL;
+                          }
                         else
+                          {
                           scramble[curr][0] = 1;
                           scramble[curr][1] = rnd.nextInt(2);
                           scramble[curr][2] = 1;
                           mLastRot = LAST_SL;
                           updateCornerQuats(scramble[curr]);
                           scramble[curr][1] = (1<<scramble[curr][1]);
                           int axis3 = 1;
                           int row3  = rnd.nextInt(2);
                           int angle3= 1;
                           mLastRot  = LAST_SL;
                           updateCornerQuats(axis3,row3,angle3);
                           scramble[curr].set(axis3, 1<<row3, angle3);
                           computePermittedAngles();
+                          }
                         break;
           case LAST_UL: scramble[curr][0] = 1;
                         scramble[curr][1] = rnd.nextInt(2);
                         scramble[curr][2] = 1;
                         mLastRot = LAST_SL;
                         updateCornerQuats(scramble[curr]);
           case LAST_UL: int axis4 = 1;
                         int row4  = rnd.nextInt(2);
                         int angle4= 1;
                         mLastRot  = LAST_SL;
                         updateCornerQuats(axis4,row4,angle4);
                         computePermittedAngles();
                         scramble[curr][1] = (1<<scramble[curr][1]);
                         scramble[curr].set(axis4, 1<<row4, angle4);
                         break;
+          }
+        }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TYPE 2
       private void buildMoveForced(int[][] scramble, Random rnd, int curr)
       private void buildMoveForced(ObjectMove[] scramble, Random rnd, int curr)
+        {
         ScrambleStateLocallyBandaged currState = mStatesHistory.get(curr);
         int indexExcluded = curr>0 ? scramble[curr-1][0] : ScrambleStateLocallyBandaged.AXIS_NONE;
         int numMoves = currState.numMoves(indexExcluded);
         int axisExcluded = curr>0 ? scramble[curr-1].getAxis() : ScrambleStateLocallyBandaged.AXIS_NONE;
         int numMoves = currState.numMoves(axisExcluded);
         ObjectSignature signature;
         if( numMoves==0 )
+          {
           indexExcluded = ScrambleStateLocallyBandaged.AXIS_NONE;
           numMoves = currState.numMoves(indexExcluded);
           axisExcluded = ScrambleStateLocallyBandaged.AXIS_NONE;
           numMoves = currState.numMoves(axisExcluded);
+          }
         if( numMoves==0 )
+          {
           scramble[curr][0] = 0;
           scramble[curr][1] = 0;
           scramble[curr][2] = 0;
           scramble[curr].set(0,0,0);
           signature = currState.getSignature();
+          }
         else
+          {
           int randMove = rnd.nextInt(numMoves);
           int moveIndex = currState.getNthMove(randMove,indexExcluded);
           int moveIndex = currState.getNthMove(randMove,axisExcluded);
           signature = currState.getMove(moveIndex);
           currState.fillOutScramble(scramble[curr],moveIndex);
+          }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TYPE 2
       private boolean buildMove2Cons(int[][] scramble, Random rnd, int curr)
       private boolean buildMove2Cons(ObjectMove[] scramble, Random rnd, int curr)
+        {
         ScrambleStateLocallyBandaged currState = mStatesHistory.get(curr);
         boolean lock= (curr>=2 && scramble[curr-2][0]==scramble[curr-1][0] );
         int axisExcluded = lock ? scramble[curr-1][0] : ScrambleStateLocallyBandaged.AXIS_NONE;
         int layerExcluded= !lock && curr>=1 ? scramble[curr-1][1] : -1;
         boolean lock= (curr>=2 && scramble[curr-2].getAxis()==scramble[curr-1].getAxis() );
         int axisExcluded = lock ? scramble[curr-1].getAxis() : ScrambleStateLocallyBandaged.AXIS_NONE;
         int AlayerExcluded= !lock && curr>=1 ? scramble[curr-1][1] : -1;
         int numMoves = currState.numMoves(axisExcluded,layerExcluded);
         while( numMoves==0 )

src/main/java/org/distorted/objectlib/solvers/verifiers/SolverKociembaCUBE3.java
187	187	{
188	188	int numMoves = result.length()/4;
189	189	int[][] moves= new int[numMoves][3];
190
191	190	RubikPattern.parseMoves(moves,numMoves,result);
192	191	screen.setSolved(moves,0,null);
193	192	}

Also available in: Unified diff

Project

General

Profile

TwistyPuzzleLib

Revision baf80e60

Added by Leszek Koltunski 9 months ago