/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision 680f921e

Added by Leszek Koltunski over 4 years ago

ID 680f921e1e70000159323158d2042e43e335baa2
Parent c5b4af4a
Child 2ef489e2

Progress making the Diamond class support any size.

       private static final float DIST = 0.50f;
       // centers of the 6 octahedrons + 8 tetrahedrons ( i.e. of the all 14 cubits)
       private static final float[][] CENTERS = new float[][]
+             {
                  { DIST,          0, DIST },
                  { DIST,          0,-DIST },
                  {-DIST,          0,-DIST },
                  {-DIST,          0, DIST },
                  {    0, DIST*SQ2  ,    0 },
                  {    0,-DIST*SQ2  ,    0 },
                  {    0, DIST*SQ2/2, DIST },
                  { DIST, DIST*SQ2/2,    0 },
                  {    0, DIST*SQ2/2,-DIST },
                  {-DIST, DIST*SQ2/2,    0 },
                  {    0,-DIST*SQ2/2, DIST },
                  { DIST,-DIST*SQ2/2,    0 },
                  {    0,-DIST*SQ2/2,-DIST },
                  {-DIST,-DIST*SQ2/2,    0 }
              };
       // Colors of the faces of cubits. Each cubit has 8 faces
       private static final int[][] mFaceMap = new int[][]
       private static final int[][] mOctaFaceMap = new int[][]
+             {
                { 6,1,8,8, 2,5,8,8 },
                { 8,1,3,8, 8,5,7,8 },
-...
                { 6,8,8,4, 2,8,8,0 },
                { 6,1,3,4, 8,8,8,8 },
                { 8,8,8,8, 2,5,7,0 },
                { 6,8,8,8, 8,8,8,8 },
                { 1,8,8,8, 8,8,8,8 },
                { 3,8,8,8, 8,8,8,8 },
                { 4,8,8,8, 8,8,8,8 },
                { 2,8,8,8, 8,8,8,8 },
                { 5,8,8,8, 8,8,8,8 },
                { 7,8,8,8, 8,8,8,8 },
                { 0,8,8,8, 8,8,8,8 }
              };
       private static final int[] mTetraFaceMap = new int[] { 1, 3, 4, 6, 5, 7, 0, 2 };
       private static MeshBase mOctaMesh, mTetraMesh;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float[] getCuts(int size)
       float[] getCuts(int numLayers)
+        {
         float[] cuts = new float[1];
         cuts[0] = 0.0f;
         return cuts;
         if( numLayers<2 )
+          {
           return null;
+          }
         else
+          {
           float[] cuts = new float[numLayers-1];
           float dist = SQ6*0.666f;
           float cut  = 0.5f*dist*(2-numLayers);
           for(int i=0; i<numLayers-1; i++)
+            {
             cuts[i] = cut;
             cut += dist;
+            }
           return cuts;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float[][] getCubitPositions(int size)
       private int getNumOctahedrons(int layers)
+        {
         return layers==1 ? 1 : 4*(layers-1)*(layers-1) + 2;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int getNumTetrahedrons(int layers)
+        {
         return 4*layers*(layers-1);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int createOctahedrons(float[][] centers, int index, int layers, float height)
+        {
         float x = DIST*(layers-1);
         float z = DIST*(layers+1);
         for(int i=0; i<layers; i++, index++)
+          {
           z -= 2*DIST;
           centers[index][0] = x;
           centers[index][1] = height;
           centers[index][2] = z;
+          }
         for(int i=0; i<layers-1; i++, index++)
+          {
           x -= 2*DIST;
           centers[index][0] = x;
           centers[index][1] = height;
           centers[index][2] = z;
+          }
         for(int i=0; i<layers-1; i++, index++)
+          {
           z += 2*DIST;
           centers[index][0] = x;
           centers[index][1] = height;
           centers[index][2] = z;
+          }
         for(int i=0; i<layers-2; i++, index++)
+          {
           x += 2*DIST;
           centers[index][0] = x;
           centers[index][1] = height;
           centers[index][2] = z;
+          }
         return index;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int createTetrahedrons(float[][] centers, int index, int layers, float height)
+        {
         float x = DIST*(layers-1);
         float z = DIST*layers;
         for(int i=0; i<layers-1; i++, index++)
+          {
           z -= 2*DIST;
           centers[index][0] = x;
           centers[index][1] = height;
           centers[index][2] = z;
+          }
         x += DIST;
         z -= DIST;
         for(int i=0; i<layers-1; i++, index++)
+          {
           x -= 2*DIST;
           centers[index][0] = x;
           centers[index][1] = height;
           centers[index][2] = z;
+          }
         x -= DIST;
         z -= DIST;
         for(int i=0; i<layers-1; i++, index++)
+          {
           z += 2*DIST;
           centers[index][0] = x;
           centers[index][1] = height;
           centers[index][2] = z;
+          }
         x -= DIST;
         z += DIST;
         for(int i=0; i<layers-1; i++, index++)
+          {
           x += 2*DIST;
           centers[index][0] = x;
           centers[index][1] = height;
           centers[index][2] = z;
+          }
         return index;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float[][] getCubitPositions(int layers)
+        {
         int numO = getNumOctahedrons(layers);
         int numT = getNumTetrahedrons(layers);
         int index = 0;
         float height = 0.0f;
         float[][] CENTERS = new float[numO+numT][3];
         index = createOctahedrons(CENTERS,index,layers,height);
         for(int i=layers-1; i>0; i--)
+          {
           height += SQ2*DIST;
           index = createOctahedrons(CENTERS,index,i,+height);
           index = createOctahedrons(CENTERS,index,i,-height);
+          }
         height = DIST*SQ2/2;
         for(int i=layers; i>1; i--)
+          {
           index = createTetrahedrons(CENTERS,index,i,+height);
           index = createTetrahedrons(CENTERS,index,i,-height);
           height += SQ2*DIST;
+          }
         return CENTERS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TODO:
       private Static4D getQuat(int cubit)
       private int retFaceTetraBelongsTo(int tetra, int numLayers)
+        {
         switch(cubit)
         switch(tetra)
+          {
           case  0:
           case  1:
           case  2:
           case  3:
           case  4:
           case  5:
           case  6: return QUATS[0];                          // unit quat
           case  7: return new Static4D(0,-SQ2/2,0,SQ2/2);    //  90 along Y
           case  8: return QUATS[1];                          // 180 along Y
           case  9: return new Static4D(0,+SQ2/2,0,SQ2/2);    //  90 along Y
           case 10: return new Static4D(0,     0,1,    0);    // 180 along Z
           case 11: return new Static4D(SQ2/2, 0,SQ2/2,0);    //
           case 12: return new Static4D(     1,0,0,    0);    // 180 along X
           case 13: return new Static4D(-SQ2/2,0,SQ2/2,0);    //
           case 0 : return 0;
           case 1 : return 1;
           case 2 : return 2;
           case 3 : return 3;
           case 4 : return 4;
           case 5 : return 5;
           case 6 : return 6;
           case 7 : return 7;
           default: return 8;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private Static4D getQuat(int cubit, int numLayers, int numO)
+        {
         if( cubit<numO ) return QUATS[0];
         switch( retFaceTetraBelongsTo(cubit-numO, numLayers) )
+          {
           case 0: return new Static4D(0,-SQ2/2,0,SQ2/2);    //  90 along Y
           case 1: return QUATS[1];                          // 180 along Y
           case 2: return new Static4D(0,+SQ2/2,0,SQ2/2);    //  90 along Y
           case 3: return QUATS[0];                          // unit quat
           case 4: return new Static4D(SQ2/2, 0,SQ2/2,0);    //
           case 5: return new Static4D(     1,0,0,    0);    // 180 along X
           case 6: return new Static4D(-SQ2/2,0,SQ2/2,0);    //
           case 7: return new Static4D(0,     0,1,    0);    // 180 along Z
+          }
         return null;
-...
       MeshBase createCubitMesh(int cubit, int numLayers)
+        {
         MeshBase mesh;
         int numO = getNumOctahedrons(numLayers);
         if( cubit<6 )
         if( cubit<numO )
+          {
           if( mOctaMesh==null ) mOctaMesh = FactoryCubit.getInstance().createOctaMesh();
           mesh = mOctaMesh.copy(true);
-...
           mesh = mTetraMesh.copy(true);
+          }
         MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit), new Static3D(0,0,0) );
         Static4D sQ = getQuat(cubit,numLayers,numO);
         MatrixEffectQuaternion quat = new MatrixEffectQuaternion( sQ, new Static3D(0,0,0) );
         mesh.apply(quat,0xffffffff,0);
         return mesh;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TODO
       int getFaceColor(int cubit, int cubitface, int size)
       int getFaceColor(int cubit, int cubitface, int numLayers)
+        {
         return mFaceMap[cubit][cubitface];
         int numO = getNumOctahedrons(numLayers);
         if( cubit<numO )
+          {
           return mOctaFaceMap[cubit][cubitface];
+          }
         else
+          {
           return cubitface>0 ? 8 : mTetraFaceMap[retFaceTetraBelongsTo(cubit-numO, numLayers)];
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       float[] getRowChances(int numLayers)
+        {
         float[] chances = new float[2];
         float[] chances = new float[numLayers];
         chances[0] = 0.5f;
         chances[1] = 1.0f;
         for(int i=0; i<numLayers; i++) chances[i] = ((float)(i+1))/numLayers;
         return chances;
+        }
-...
     // 2) cubits 7,13: can also be QUAT 4,8
     // 3) cubits 8,10: can also be QUAT 7,11
     // 4) cubits 9,11: can also be QUAT 5,9
     // TODO
       public boolean isSolved()
+        {

       private static final float MAX_SIZE_CHANGE = 1.35f;
       private static final float MIN_SIZE_CHANGE = 0.75f;
       private static final boolean mCreateFromDMesh = true;
       private static final boolean mCreateFromDMesh = false;
       private static final Static3D CENTER = new Static3D(0,0,0);
       private static final int POST_ROTATION_MILLISEC = 500;

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision 680f921e

Added by Leszek Koltunski over 4 years ago