/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision 3f3ff476

Added by Leszek Koltunski about 4 years ago

ID 3f3ff476e42fe3c9daca64deb0a7b3a79e476276
Parent 8a494f47
Child eb389a97

Beginnings of support for any-sized Skewb.

            ),
       SKEW (
              new int[][] {
                            {2 , 11, R.raw.skewb, R.drawable.ui_small_skewb, R.drawable.ui_medium_skewb, R.drawable.ui_big_skewb, R.drawable.ui_huge_skewb} ,
                          },
              TwistySkewb.class,
              new MovementSkewb(),
            ),
       REDI (
              new int[][] {
                            {3 , 14, R.raw.redi, R.drawable.ui_small_redi, R.drawable.ui_medium_redi, R.drawable.ui_big_redi, R.drawable.ui_huge_redi} ,
-...
                          },
              TwistyHelicopter.class,
              new MovementHelicopter(),
            ),
       SKEW (
              new int[][] {
                            {2 , 11, R.raw.skewb, R.drawable.ui_small_skewb, R.drawable.ui_medium_skewb, R.drawable.ui_big_skewb, R.drawable.ui_huge_skewb} ,
                            {3 , 15, R.raw.skewb, R.drawable.ui_small_skewb, R.drawable.ui_medium_skewb, R.drawable.ui_big_skewb, R.drawable.ui_huge_skewb} ,
                            {4 , 20, R.raw.skewb, R.drawable.ui_small_skewb, R.drawable.ui_medium_skewb, R.drawable.ui_big_skewb, R.drawable.ui_huge_skewb} ,
                          },
              TwistySkewb.class,
              new MovementSkewb(),
            ),
+      ;
-...
           case 2: return new TwistyDiamond   (size, quat, texture, mesh, effects, moves, res, scrWidth);
           case 3: return new TwistyDino6     (size, quat, texture, mesh, effects, moves, res, scrWidth);
           case 4: return new TwistyDino4     (size, quat, texture, mesh, effects, moves, res, scrWidth);
           case 5: return new TwistySkewb     (size, quat, texture, mesh, effects, moves, res, scrWidth);
           case 6: return new TwistyRedi      (size, quat, texture, mesh, effects, moves, res, scrWidth);
           case 7: return new TwistyHelicopter(size, quat, texture, mesh, effects, moves, res, scrWidth);
           case 5: return new TwistyRedi      (size, quat, texture, mesh, effects, moves, res, scrWidth);
           case 6: return new TwistyHelicopter(size, quat, texture, mesh, effects, moves, res, scrWidth);
           case 7: return new TwistySkewb     (size, quat, texture, mesh, effects, moves, res, scrWidth);
+          }
         return null;

src/main/java/org/distorted/objects/TwistyCube.java
39	39
40	40	class TwistyCube extends TwistyObject
41	41	{
42		static final float SQ2 = (float)Math.sqrt(2);
43
44	42	// the three rotation axis of a RubikCube. Must be normalized.
45	43	static final Static3D[] ROT_AXIS = new Static3D[]
46	44	{

     public class TwistyDiamond extends TwistyObject
+    {
       private static final float SQ2 = (float)Math.sqrt(2);
       private static final float SQ3 = (float)Math.sqrt(3);
       private static final float SQ6 = (float)Math.sqrt(6);
       private static final int FACES_PER_CUBIT =8;
       // the four rotation axis of a Diamond. Must be normalized.
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // The Diamond is solved if and only if:
     //
     // 1) all 5 octahedrons are rotated with the same quat
     // 1) all 6 octahedrons are rotated with the same quat
     // 2) the 8 tetrahedrons are rotated with the quat and, optionally, the can also be rotated
     //    by multitudes of 120 degrees along the face they are the center of.
     //

src/main/java/org/distorted/objects/TwistyDino.java
40	40
41	41	public abstract class TwistyDino extends TwistyObject
42	42	{
43		private static final float SQ3 = (float)Math.sqrt(3);
44
45	43	// the four rotation axis of a RubikDino. Must be normalized.
46	44	static final Static3D[] ROT_AXIS = new Static3D[]
47	45	{

     public class TwistyHelicopter extends TwistyObject
+    {
       private static final float SQ2 = (float)Math.sqrt(2);
       private static final int FACES_PER_CUBIT =6;
       // the six rotation axis of a Helicopter. Must be normalized.

       static final int COLOR_VIOLET = 0xff7700bb;
       static final int COLOR_BLACK  = 0xff000000;
       static final float SQ2 = (float)Math.sqrt(2);
       static final float SQ3 = (float)Math.sqrt(3);
       static final float SQ6 = (float)Math.sqrt(6);
       private static final float NODE_RATIO = 1.40f;
       private static final float MAX_SIZE_CHANGE = 1.35f;
       private static final float MIN_SIZE_CHANGE = 0.8f;
       private static boolean mCreateFromDMesh = true;
       private static boolean mCreateFromDMesh = false;
       private static final Static3D CENTER = new Static3D(0,0,0);
       private static final int POST_ROTATION_MILLISEC = 500;
-...
         resizeFBO(mNodeSize, (int)(NODE_RATIO*mNodeSize));
         mSize = size;
         mList = list;
         mOrigPos = getCubitPositions(size);
-...
         if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE;
         if( mObjectScreenRatio<MIN_SIZE_CHANGE) mObjectScreenRatio = MIN_SIZE_CHANGE;
         mSize = size;
         computeStartAndStep(mOrigPos);
         mNodeScale= new Static3D(1,NODE_RATIO,1);
         mQuat = quat;

src/main/java/org/distorted/objects/TwistyPyraminx.java
39	39
40	40	public class TwistyPyraminx extends TwistyObject
41	41	{
42		private static final float SQ2 = (float)Math.sqrt(2);
43		private static final float SQ3 = (float)Math.sqrt(3);
44		private static final float SQ6 = (float)Math.sqrt(6);
45
46	42	static final Static3D[] ROT_AXIS = new Static3D[]
47	43	{
48	44	new Static3D( 0,-SQ3/3,-SQ6/3),

     public class TwistyRedi extends TwistyObject
+    {
       private static final float SQ2 = (float)Math.sqrt(2);
       private static final float SQ3 = (float)Math.sqrt(3);
       private static final int FACES_PER_CUBIT =6;
       // the four rotation axis of a RubikRedi. Must be normalized.

     import android.graphics.Canvas;
     import android.graphics.Paint;
     import org.distorted.library.effect.MatrixEffect;
     import org.distorted.library.effect.MatrixEffectQuaternion;
     import org.distorted.library.effect.MatrixEffectScale;
     import org.distorted.library.main.DistortedEffects;
     import org.distorted.library.main.DistortedTexture;
     import org.distorted.library.mesh.MeshBase;
-...
     public class TwistySkewb extends TwistyObject
+    {
       private static final float SQ2 = (float)Math.sqrt(2);
       private static final float SQ3 = (float)Math.sqrt(3);
       private static final int FACES_PER_CUBIT =6;
       // the four rotation axis of a RubikSkewb. Must be normalized.
-...
                new Static4D(  0.5f, -0.5f, -0.5f, -0.5f )
              };
       private static final float DIST_CORNER = 0.50f;
       private static final float DIST_CENTER = 0.49f;
       private static final int[][] mCornerMap =
+             {
                {  4, 2, 0, 18,18,18 },
                {  2, 5, 0, 18,18,18 },
                {  3, 4, 0, 18,18,18 },
                {  5, 3, 0, 18,18,18 },
                {  1, 2, 4, 18,18,18 },
                {  5, 2, 1, 18,18,18 },
                {  4, 3, 1, 18,18,18 },
                {  1, 3, 5, 18,18,18 },
              };
       // centers of the 8 corners + 6 sides ( i.e. of the all 14 cubits)
       private static final Static3D[] CENTERS = new Static3D[]
       private static final int[][] mEdgeMap =
+             {
                new Static3D( DIST_CORNER, DIST_CORNER, DIST_CORNER ),
                new Static3D( DIST_CORNER, DIST_CORNER,-DIST_CORNER ),
                new Static3D( DIST_CORNER,-DIST_CORNER, DIST_CORNER ),
                new Static3D( DIST_CORNER,-DIST_CORNER,-DIST_CORNER ),
                new Static3D(-DIST_CORNER, DIST_CORNER, DIST_CORNER ),
                new Static3D(-DIST_CORNER, DIST_CORNER,-DIST_CORNER ),
                new Static3D(-DIST_CORNER,-DIST_CORNER, DIST_CORNER ),
                new Static3D(-DIST_CORNER,-DIST_CORNER,-DIST_CORNER ),
                new Static3D( DIST_CENTER,        0.0f,        0.0f ),
                new Static3D(-DIST_CENTER,        0.0f,        0.0f ),
                new Static3D(        0.0f, DIST_CENTER,        0.0f ),
                new Static3D(        0.0f,-DIST_CENTER,        0.0f ),
                new Static3D(        0.0f,        0.0f, DIST_CENTER ),
                new Static3D(        0.0f,        0.0f,-DIST_CENTER ),
                { 10, 8, 18,18,18,18 },
                {  6,10, 18,18,18,18 },
                { 10, 9, 18,18,18,18 },
                {  7,10, 18,18,18,18 },
                {  8, 6, 18,18,18,18 },
                {  9, 6, 18,18,18,18 },
                {  9, 7, 18,18,18,18 },
                {  8, 7, 18,18,18,18 },
                { 11, 8, 18,18,18,18 },
                {  6,11, 18,18,18,18 },
                { 11, 9, 18,18,18,18 },
                {  7,11, 18,18,18,18 }
              };
       // Colors of the faces of cubits. Each cubit, even the face pyramid, has 6 faces
       // (the face has one extra 'fake' face so that everything would have the same number)
       private static final int[][] mFaceMap = new int[][]
       private static final int[][] mCenterMap =
+             {
                { 4,2,0, 12,12,12 },
                { 2,5,0, 12,12,12 },
                { 3,4,0, 12,12,12 },
                { 5,3,0, 12,12,12 },
                { 1,2,4, 12,12,12 },
                { 5,2,1, 12,12,12 },
                { 4,3,1, 12,12,12 },
                { 1,3,5, 12,12,12 },
                { 6 , 12,12,12,12,12 },
                { 7 , 12,12,12,12,12 },
                { 8 , 12,12,12,12,12 },
                { 9 , 12,12,12,12,12 },
                { 10, 12,12,12,12,12 },
                { 11, 12,12,12,12,12 },
                { 12, 18,18,18,18,18 },
                { 13, 18,18,18,18,18 },
                { 14, 18,18,18,18,18 },
                { 15, 18,18,18,18,18 },
                { 16, 18,18,18,18,18 },
                { 17, 18,18,18,18,18 },
              };
       private static MeshBase mCornerMesh, mFaceMesh;
       private static MeshBase mCornerMesh, mFaceMesh, mEdgeMesh;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         super(size, 60, quat, texture, mesh, effects, moves, ObjectList.SKEW, res, scrWidth);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int getNumCorners(int size)
+        {
         return 8;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int getNumEdges(int size)
+        {
         return (size-2)*12;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int getNumCenters(int size)
+        {
         return ((size-2)*(size-2) + (size-1)*(size-1))*6;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float getScreenRatio()
+        {
         return 1.0f;
         int size = getSize();
         return size/ (2.0f*(size-1));
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Each face has two types of a texture: the central square and the triangle in the corner.
       int getNumStickerTypes()
+        {
         return 2;
         return 3;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       Static3D[] getCubitPositions(int size)
+        {
         final float DIST_CORNER = (size-1)*0.50f;
         final float DIST_EDGE   = (size-1)*0.50f;
         final float DIST_CENTER = (size-1)*0.50f;
         final int numCorners = getNumCorners(size);
         final int numEdges   = getNumEdges(size);
         final int numCenters = getNumCenters(size);
         final Static3D[] CENTERS = new Static3D[numCorners+numEdges+numCenters];
         /// CORNERS //////////////////////////////////////////////
         CENTERS[0] = new Static3D( DIST_CORNER, DIST_CORNER, DIST_CORNER );
         CENTERS[1] = new Static3D( DIST_CORNER, DIST_CORNER,-DIST_CORNER );
         CENTERS[2] = new Static3D( DIST_CORNER,-DIST_CORNER, DIST_CORNER );
         CENTERS[3] = new Static3D( DIST_CORNER,-DIST_CORNER,-DIST_CORNER );
         CENTERS[4] = new Static3D(-DIST_CORNER, DIST_CORNER, DIST_CORNER );
         CENTERS[5] = new Static3D(-DIST_CORNER, DIST_CORNER,-DIST_CORNER );
         CENTERS[6] = new Static3D(-DIST_CORNER,-DIST_CORNER, DIST_CORNER );
         CENTERS[7] = new Static3D(-DIST_CORNER,-DIST_CORNER,-DIST_CORNER );
         /// EDGES ///////////////////////////////////////////////
         final float[][]  edgeTable =
+            {
                 {0,+DIST_EDGE,+DIST_EDGE},
                 {+DIST_EDGE,0,+DIST_EDGE},
                 {0,-DIST_EDGE,+DIST_EDGE},
                 {-DIST_EDGE,0,+DIST_EDGE},
                 {+DIST_EDGE,+DIST_EDGE,0},
                 {+DIST_EDGE,-DIST_EDGE,0},
                 {-DIST_EDGE,-DIST_EDGE,0},
                 {-DIST_EDGE,+DIST_EDGE,0},
                 {0,+DIST_EDGE,-DIST_EDGE},
                 {+DIST_EDGE,0,-DIST_EDGE},
                 {0,-DIST_EDGE,-DIST_EDGE},
                 {-DIST_EDGE,0,-DIST_EDGE}
             };
         int index=8;
         for (float[] edges : edgeTable)
+          {
           float c = (3-size)*0.5f;
           for (int j=0; j<size-2; j++, c+=1.0f, index++)
+            {
             CENTERS[index] = new Static3D( edges[0]==0 ? c : edges[0] ,
                                            edges[1]==0 ? c : edges[1] ,
                                            edges[2]==0 ? c : edges[2] );
+            }
+          }
         /// CENTERS //////////////////////////////////////////////
         final float X= -1000.0f;
         final float Y= -1001.0f;
         final float[][]  centerTable =
+            {
                 {+DIST_CENTER,X,Y},
                 {-DIST_CENTER,X,Y},
                 {X,+DIST_CENTER,Y},
                 {X,-DIST_CENTER,Y},
                 {X,Y,+DIST_CENTER},
                 {X,Y,-DIST_CENTER}
             };
         float x,y, cen0, cen1, cen2;
         for( float[] centers : centerTable )
+          {
           x = (2-size)*0.5f;
           for(int i=0; i<size-1; i++, x+=1.0f)
+            {
             y = (2-size)*0.5f;
             for(int j=0; j<size-1; j++, y+=1.0f, index++)
+              {
                    if( centers[0]==Y ) cen0 = y;
               else if( centers[0]==X ) cen0 = x;
               else                     cen0 = centers[0];
                    if( centers[1]==Y ) cen1 = y;
               else if( centers[1]==X ) cen1 = x;
               else                     cen1 = centers[1];
                    if( centers[2]==Y ) cen2 = y;
               else if( centers[2]==X ) cen2 = x;
               else                     cen2 = centers[2];
               CENTERS[index] = new Static3D(cen0,cen1,cen2);
+              }
+            }
           x = (3-size)*0.5f;
           for(int i=0; i<size-2; i++, x+=1.0f)
+            {
             y = (3-size)*0.5f;
             for(int j=0; j<size-2; j++, y+=1.0f, index++)
+              {
                    if( centers[0]==Y ) cen0 = y;
               else if( centers[0]==X ) cen0 = x;
               else                     cen0 = centers[0];
                    if( centers[1]==Y ) cen1 = y;
               else if( centers[1]==X ) cen1 = x;
               else                     cen1 = centers[1];
                    if( centers[2]==Y ) cen2 = y;
               else if( centers[2]==X ) cen2 = x;
               else                     cen2 = centers[2];
               CENTERS[index] = new Static3D(cen0,cen1,cen2);
+              }
+            }
+          }
         return CENTERS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private Static4D getQuat(int cubit)
       private Static4D getQuat(int cubit, int size)
+        {
         switch(cubit)
         int numCorners = getNumCorners(size);
         int numEdges   = getNumEdges(size);
         if( cubit<numCorners )
+          {
           switch(cubit)
+            {
             case  0: return QUATS[0];                          //  unit quat
             case  1: return new Static4D( SQ2/2,0,0,SQ2/2);    //  90 along X
             case  2: return new Static4D(-SQ2/2,0,0,SQ2/2);    // -90 along X
             case  3: return QUATS[1];                          // 180 along X
             case  4: return new Static4D(0, SQ2/2,0,SQ2/2);    //  90 along Y
             case  5: return QUATS[2];                          // 180 along Y
             case  6: return QUATS[3];                          // 180 along Z
             case  7: return new Static4D(SQ2/2,0,-SQ2/2,0);    // 180 along (SQ2/2,0,-SQ2/2)
+            }
+          }
         else if( cubit<numCorners+numEdges )
+          {
           int edge = (cubit-numCorners)/(size-2);
           switch(edge)
+            {
             case  0: return QUATS[ 0];
             case  1: return QUATS[ 5];
             case  2: return QUATS[ 3];
             case  3: return QUATS[11];
             case  4: return QUATS[ 4];
             case  5: return QUATS[ 7];
             case  6: return QUATS[ 9];
             case  7: return QUATS[10];
             case  8: return QUATS[ 2];
             case  9: return QUATS[ 8];
             case 10: return QUATS[ 1];
             case 11: return QUATS[ 6];
+            }
+          }
         else
+          {
           case  0: return QUATS[0];                          //  unit quat
           case  1: return new Static4D( SQ2/2,0,0,SQ2/2);    //  90 along X
           case  2: return new Static4D(-SQ2/2,0,0,SQ2/2);    // -90 along X
           case  3: return QUATS[1];                          // 180 along X
           case  4: return new Static4D(0, SQ2/2,0,SQ2/2);    //  90 along Y
           case  5: return QUATS[2];                          // 180 along Y
           case  6: return QUATS[3];                          // 180 along Z
           case  7: return new Static4D(SQ2/2,0,-SQ2/2,0);    // 180 along (SQ2/2,0,-SQ2/2)
           case  8: return new Static4D(0,-SQ2/2,0,SQ2/2);    // -90 along Y
           case  9: return new Static4D(0, SQ2/2,0,SQ2/2);    //  90 along Y
           case 10: return new Static4D( SQ2/2,0,0,SQ2/2);    //  90 along X
           case 11: return new Static4D(-SQ2/2,0,0,SQ2/2);    // -90 along X
           case 12: return QUATS[0];                          //  unit quaternion
           case 13: return QUATS[1];                          // 180 along X
           int center = (cubit-numCorners-numEdges)/((size-2)*(size-2)+(size-1)*(size-1));
           switch(center)
+            {
             case 0: return new Static4D(0,-SQ2/2,0,SQ2/2);    // -90 along Y
             case 1: return new Static4D(0, SQ2/2,0,SQ2/2);    //  90 along Y
             case 2: return new Static4D( SQ2/2,0,0,SQ2/2);    //  90 along X
             case 3: return new Static4D(-SQ2/2,0,0,SQ2/2);    // -90 along X
             case 4: return QUATS[0];                          //  unit quaternion
             case 5: return QUATS[1];                          // 180 along X
+            }
+          }
         return null;
-...
+        {
         MeshBase mesh;
         if( cubit<8 )
         int size = getSize();
         int numCorners = getNumCorners(size);
         int numEdges   = getNumEdges(size);
         if( cubit<numCorners )
+          {
           if( mCornerMesh==null ) mCornerMesh = CubitFactory.getInstance().createSkewbCornerMesh();
           mesh = mCornerMesh.copy(true);
+          }
         else if( cubit<numCorners+numEdges )
+          {
           if( mEdgeMesh==null )
+            {
             mEdgeMesh = CubitFactory.getInstance().createDinoMesh();
             MatrixEffect effect = new MatrixEffectScale(1.0f/3);
             mEdgeMesh.apply(effect,-1,0);
             mEdgeMesh.addEmptyTexComponent();
             mEdgeMesh.addEmptyTexComponent();
+            }
           mesh = mEdgeMesh.copy(true);
+          }
         else
+          {
           if( mFaceMesh==null ) mFaceMesh = CubitFactory.getInstance().createSkewbFaceMesh();
           mesh = mFaceMesh.copy(true);
+          }
         MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit), new Static3D(0,0,0) );
         MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit,size), new Static3D(0,0,0) );
         mesh.apply(quat,0xffffffff,0);
         return mesh;
-...
       int getFaceColor(int cubit, int cubitface, int size)
+        {
         return mFaceMap[cubit][cubitface];
         int numCorners = getNumCorners(size);
         int numEdges   = getNumEdges(size);
         if( cubit<numCorners )
+          {
           return mCornerMap[cubit][cubitface];
+          }
         else if( cubit<numCorners+numEdges )
+          {
           int edge = (cubit-numCorners)/(size-2);
           return mEdgeMap[edge][cubitface];
+          }
         else
+          {
           int center = (cubit-numCorners-numEdges)/((size-2)*(size-2)+(size-1)*(size-1));
           return mCenterMap[center][cubitface];
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           float[] vertices = { -E+E/4,E/4, E/4,-E+E/4, E/4,E/4};
           drawRoundedPolygon(canvas, paint, left, vertices, S, FACE_COLORS[face], R);
+          }
         else if( face<2*COLORS )
+          {
           float F = 0.5f;
           float R = 0.025f;
           float S = 0.05f;
           float[] vertices = { -F,F/3, 0,-2*F/3, +F,F/3 };
           drawRoundedPolygon(canvas, paint, left, vertices, S, FACE_COLORS[face-COLORS], R);
+          }
         else
+          {
           float R = 0.055f;
           float S = 0.035f;
           float E = SQ2/4;
           float[] vertices = { -E,-E, +E,-E, +E,+E, -E,+E };
           drawRoundedPolygon(canvas, paint, left, vertices, S, FACE_COLORS[face-COLORS], R);
           drawRoundedPolygon(canvas, paint, left, vertices, S, FACE_COLORS[face-2*COLORS], R);
+          }
+        }
-...
       float[] getRowChances()
+        {
         float[] chances = new float[2];
         int size = getSize();
         float[] chances = new float[size];
         chances[0] = 0.5f;
         chances[1] = 1.0f;
         for(int i=0; i<size; i++)
+          {
           chances[i] = (float)(i+1)/size;
+          }
         return chances;
+        }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // The Skewb is solved if and only if:
     //
     // 1) all of its corner cubits are rotated with the same quat
     // 1) all of its corner and edge cubits are rotated with the same quat
     // 2) all its face cubits are rotated with the same quat like the corner ones,
     //    and optionally they also might be upside down.
     //

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision 3f3ff476

Added by Leszek Koltunski about 4 years ago