/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision cda32fc1

Added by Leszek Koltunski over 3 years ago

ID cda32fc19974f5428851c358133654579abefa65
Parent e1dc3366
Child aa26ba7f

Convert the Redi to the new scrambling paradigm.

src/main/java/org/distorted/helpers/ScrambleState.java
138	138	{
139	139	return ( indexExcluded>=0 && indexExcluded<mNumAxis ) ? mTotal-mNum[indexExcluded] : mTotal;
140	140	}
141
142		///////////////////////////////////////////////////////////////////////////////////////////////////
143
144		public int[] getInfo(int num, int indexExcluded)
145		{
146		int index = getIndex(num,indexExcluded);
147
148		mTmp[0] = mInfo[LEN*index ]; // axis
149		mTmp[1] = mInfo[LEN*index+1]; // row
150		mTmp[2] = mInfo[LEN*index+2]; // angle
151		mTmp[3] = mInfo[LEN*index+3]; // next state
152
153		return mTmp;
154		}
155	141	}

     import org.distorted.helpers.ObjectShape;
     import org.distorted.helpers.ObjectSticker;
     import org.distorted.helpers.ScrambleState;
     import org.distorted.library.main.DistortedEffects;
     import org.distorted.library.main.DistortedTexture;
     import org.distorted.library.mesh.MeshSquare;
-...
                  { -0.3125f, 0.4375f, -0.3125f, -0.1875f, 0.0f, -0.5f, 0.3125f, -0.1875f, 0.3125f, 0.4375f }
               };
       private static int[][] mScrambleTable;
       private static int[] mPossibleAxis, mPossibleLayers;
       private static int[] mNumOccurences;
       private static final ObjectSticker[] mStickers;
       static
-...
+          }
+        }
       private int mCurrState;
       private int mIndexExcluded;
       private final ScrambleState[] mStates;
       private int[][] mScrambleTable;
       private int[] mNumOccurences;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       TwistyRedi(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh,
                  DistortedEffects effects, int[][] moves, Resources res, int scrWidth)
+        {
         super(size, size, quat, texture, mesh, effects, moves, ObjectList.REDI, res, scrWidth);
         mStates = new ScrambleState[]
+          {
           new ScrambleState( new int[][] { {0,1,1,0,-1,1, 2,1,2,2,-1,2},{0,1,3,0,-1,3, 2,1,4,2,-1,4},{0,1,5,0,-1,5, 2,1,6,2,-1,6},{0,1,7,0,-1,7, 2,1,8,2,-1,8} } ),
           new ScrambleState( new int[][] { {                          },{0,1,3,0,-1,3              },{0,1,5,0,-1,5,             },{              2,1,8,2,-1,8} } ),
           new ScrambleState( new int[][] { {                          },{              2,1,4,2,-1,4},{              2,1,6,2,-1,6},{0,1,7,0,-1,7              } } ),
           new ScrambleState( new int[][] { {0,1,1,0,-1,1              },{                          },{              2,1,6,2,-1,6},{0,1,7,0,-1,7              } } ),
           new ScrambleState( new int[][] { {              2,1,2,2,-1,2},{                          },{0,1,5,0,-1,5,             },{              2,1,8,2,-1,8} } ),
           new ScrambleState( new int[][] { {0,1,1,0,-1,1              },{              2,1,4,2,-1,4},{                          },{0,1,7,0,-1,7              } } ),
           new ScrambleState( new int[][] { {              2,1,2,2,-1,2},{0,1,3,0,-1,3              },{                          },{              2,1,8,2,-1,8} } ),
           new ScrambleState( new int[][] { {              2,1,2,2,-1,2},{0,1,3,0,-1,3              },{0,1,5,0,-1,5,             },{                          } } ),
           new ScrambleState( new int[][] { {0,1,1,0,-1,1              },{              2,1,4,2,-1,4},{              2,1,6,2,-1,6},{                          } } ),
           };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         return 2.0f;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
       public Static3D[] getRotationAxis()
+        {
         return ROT_AXIS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[] getBasicAngle()
       private void initializeScrambling()
+        {
         return BASIC_ANGLE;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         int numLayers = getNumLayers();
       private void initializeScrambleTable(int[] first)
+        {
         if( mScrambleTable ==null ) mScrambleTable = new int[NUM_AXIS][2];
         if( mPossibleAxis  ==null ) mPossibleAxis  = new int[NUM_AXIS-1];
         if( mPossibleLayers==null ) mPossibleLayers= new int[NUM_AXIS-1];
         if( mNumOccurences ==null ) mNumOccurences = new int[NUM_AXIS-1];
         if( mScrambleTable ==null )
+          {
           mScrambleTable = new int[NUM_AXIS][numLayers];
+          }
         if( mNumOccurences ==null )
+          {
           int max=0;
         for(int i=0; i<NUM_AXIS; i++)
           for(int j=0; j<2; j++)
           for (ScrambleState mState : mStates)
+            {
             mScrambleTable[i][j] = 0;
             int tmp = mState.getTotal(-1);
             if (max < tmp) max = tmp;
+            }
         mScrambleTable[first[0]][first[1]/2] = 1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
           mNumOccurences = new int[max];
+          }
       private boolean areOpposite(int oldAxis, int newAxis, int oldRow, int nom)
+        {
         return (oldAxis+newAxis==3)^(oldRow<nom);
         for(int i=0; i<NUM_AXIS; i++)
           for(int j=0; j<numLayers; j++) mScrambleTable[i][j] = 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
       private int retNewRotationIndex(Random rnd, int nom, int[] oldRot)
       public void randomizeNewScramble(int[][] scramble, Random rnd, int curr, int totalScrambles)
+        {
         int index=0, max=0;
         for(int ax=0; ax<NUM_AXIS; ax++)
         if( curr==0 )
+          {
           if( ax!=oldRot[0] )
+            {
             mPossibleAxis[index] = ax;
             mPossibleLayers[index] = areOpposite(oldRot[0],ax,oldRot[1],nom) ? 0:1;
             int tmp = mScrambleTable[mPossibleAxis[index]][mPossibleLayers[index]];
             if( tmp>max ) max=tmp;
             index++;
+            }
           mCurrState     = 0;
           mIndexExcluded =-1;
           initializeScrambling();
+          }
         for(int ax=0; ax<NUM_AXIS-1; ax++)
+          {
           int value = mScrambleTable[mPossibleAxis[ax]][mPossibleLayers[ax]];
           mNumOccurences[ax] = max - value + (ax==0 ? 0 : mNumOccurences[ax-1]);
+          }
         int[] info= mStates[mCurrState].getRandom(rnd, mIndexExcluded, mScrambleTable, mNumOccurences);
         float random= rnd.nextFloat()*mNumOccurences[NUM_AXIS-2];
         scramble[curr][0] = info[0];
         scramble[curr][1] = info[1];
         scramble[curr][2] = info[2];
         for(int ax=0; ax<NUM_AXIS-1; ax++)
+          {
           if( random <= mNumOccurences[ax] )
+            {
             index=ax;
             break;
+            }
+          }
         mCurrState     = info[3];
         mIndexExcluded = info[0];
+        }
         mScrambleTable[mPossibleAxis[index]][mPossibleLayers[index]]++;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         return index;
       public Static3D[] getRotationAxis()
+        {
         return ROT_AXIS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
       public void randomizeNewScramble(int[][] scramble, Random rnd, int curr, int total)
       public int[] getBasicAngle()
+        {
         if( curr==0 )
+          {
           scramble[curr][0] = rnd.nextInt(NUM_AXIS);
           scramble[curr][1] = rnd.nextFloat()<=0.5f ? 0:2;
           initializeScrambleTable(scramble[curr]);
+          }
         else
+          {
           int index = retNewRotationIndex(rnd,1,scramble[curr-1]);
           scramble[curr][0] = mPossibleAxis[index];
           scramble[curr][1] = 2*mPossibleLayers[index];
+          }
         switch( rnd.nextInt(2) )
+          {
           case 0: scramble[curr][2] = -1; break;
           case 1: scramble[curr][2] =  1; break;
+          }
         return BASIC_ANGLE;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision cda32fc1

Added by Leszek Koltunski over 3 years ago