/ - Diff - TwistyPuzzleLib - Distorted Android

       // each face is split into several parts by lines coming from its center to the vertices
       public static final int TYPE_SPLIT_CORNER = 2;
       public static final int MOVEMENT_HEXAHEDRON   = 0;
       public static final int MOVEMENT_TETRAHEDRON  = 1;
       public static final int MOVEMENT_OCTAHEDRON   = 2;
       public static final int MOVEMENT_DODECAHEDRON = 3;
       public static final int MOVEMENT_SHAPECHANGE  = 4;
       static final float SQ3 = (float)Math.sqrt(3);
       static final float SQ6 = (float)Math.sqrt(6);

         return -1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static int getNumScramble(int ordinal)
+        {
         return ordinal>=0 && ordinal<NUM_OBJECTS ? objects[ordinal].mNumScrambles : 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       ObjectType(int[] numLayers, int scrambles, int sIcon, int mIcon, int bIcon, int hIcon)
-...
         mHugeIcon    = hIcon;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getNumScramble()
+        {
         return mNumScrambles;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getIconID(int size)

     import java.io.InputStream;
     import java.util.Random;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_TETRAHEDRON;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_HEXAHEDRON;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_OCTAHEDRON;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_DODECAHEDRON;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_SHAPECHANGE;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     public abstract class TwistyObject extends DistortedNode
-...
       private final Static3D mNodeScale;
       private final Static4D mQuat;
       private final int[] mNumLayers;
       private final float mRealSize;
       private final float mSize;
       private final DistortedEffects mEffects;
       private final VertexEffectRotate mRotateEffect;
       private final Dynamic1D mRotationAngle;
-...
       private int[] mTmpQuats;
       private int mNumTexRows, mNumTexCols;
       private int mRotRowBitmap;
       private int mRotAxis;
       private int mCurrentRotAxis;
       private MeshBase mMesh;
       private final TwistyObjectScrambler mScrambler;
       private Movement mMovement;
       private boolean[][] mLayerRotatable;
       private int[][][] mEnabled;
       //////////////////// SOLVED1 ////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       TwistyObject(int[] numLayers, float realSize, Static4D quat, Static3D move, DistortedTexture nodeTexture,
       TwistyObject(int[] numLayers, float size, Static4D quat, Static3D move, DistortedTexture nodeTexture,
                    MeshSquare nodeMesh, DistortedEffects nodeEffects, Resources res, int surfaceW, int surfaceH)
+        {
         super(nodeTexture,nodeEffects,nodeMesh);
-...
         resizeFBO(mNodeW,mNodeH);
         mNumLayers = numLayers;
         mRealSize = realSize;
         mSize = size;
         mOrigPos = getCubitPositions(mNumLayers);
         mAxis = getRotationAxis();
         mInitScreenRatio = getScreenRatio();
-...
         double nearestAngleInRadians = angle*Math.PI/180;
         float sinA =-(float)Math.sin(nearestAngleInRadians*0.5);
         float cosA = (float)Math.cos(nearestAngleInRadians*0.5);
         float axisX = mAxis[mRotAxis].get0();
         float axisY = mAxis[mRotAxis].get1();
         float axisZ = mAxis[mRotAxis].get2();
         float axisX = mAxis[mCurrentRotAxis].get0();
         float axisY = mAxis[mCurrentRotAxis].get1();
         float axisZ = mAxis[mCurrentRotAxis].get2();
         Static4D quat = new Static4D( axisX*sinA, axisY*sinA, axisZ*sinA, cosA);
         mRotationAngle.removeAll();
         mRotationAngleStatic.set0(0);
         for(int i=0; i<NUM_CUBITS; i++)
           if( belongsToRotation(i,mRotAxis,mRotRowBitmap) )
           if( belongsToRotation(i, mCurrentRotAxis,mRotRowBitmap) )
+            {
             int index = CUBITS[i].removeRotationNow(quat);
             mMesh.setEffectAssociation(i, CUBITS[i].computeAssociation(),index);
-...
+        {
         if( wasRotateApplied() )
+          {
           mRotAxis     = axis;
           mCurrentRotAxis = axis;
           mRotRowBitmap= computeBitmapFromRow( rowBitmap,axis );
           mRotationAngleStatic.set0(0.0f);
-...
           return;
+          }
         mRotAxis     = axis;
         mCurrentRotAxis = axis;
         mRotRowBitmap= computeBitmapFromRow( (1<<row),axis );
         mRotationAngleStatic.set0(0.0f);
         mRotationAxis.set( mAxis[axis] );
-...
+        {
         mObjectScreenRatio = sc;
         int nodeMinSize = Math.min(mNodeW,mNodeH);
         float scale = mObjectScreenRatio*mInitScreenRatio*nodeMinSize/mRealSize;
         float scale = mObjectScreenRatio*mInitScreenRatio*nodeMinSize/mSize;
         mObjectScale.set(scale,scale,scale);
+        }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public Static4D getRotationQuat()
+          {
           return mQuat;
+          }
+        {
         return mQuat;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float getSize()
+        {
         return mSize;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         return intGetObjectType(mNumLayers);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public Movement getMovement()
+        {
         if( mMovement==null )
+          {
           int[] numLayers = getNumLayers();
           if( mCuts==null ) getCuts(numLayers);
           if( mLayerRotatable==null ) mLayerRotatable = getLayerRotatable(numLayers);
           if( mEnabled==null ) mEnabled = getEnabled();
           int movementType = getMovementType();
           int movementSplit= getMovementSplit();
           switch(movementType)
+            {
             case MOVEMENT_TETRAHEDRON : mMovement = new Movement4(mAxis,mCuts,mLayerRotatable,mSize,movementSplit,mEnabled);
                                         break;
             case MOVEMENT_HEXAHEDRON  : mMovement = new Movement6(mAxis,mCuts,mLayerRotatable,mSize,movementSplit,mEnabled);
                                         break;
             case MOVEMENT_OCTAHEDRON  : mMovement = new Movement8(mAxis,mCuts,mLayerRotatable,mSize,movementSplit,mEnabled);
                                         break;
             case MOVEMENT_DODECAHEDRON: mMovement = new Movement12(mAxis,mCuts,mLayerRotatable,mSize,movementSplit,mEnabled);
                                         break;
             case MOVEMENT_SHAPECHANGE : float[] dist3D = getDist3D(numLayers);
                                         mMovement = new MovementC(mAxis,mCuts,mLayerRotatable,mSize,movementSplit,mEnabled,dist3D);
                                         break;
+            }
+          }
         return mMovement;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected abstract int getFOV();
-...
       protected abstract Static4D getQuat(int cubit, int[] numLayers);
       protected abstract ObjectShape getObjectShape(int cubit, int[] numLayers);
       protected abstract int[] getSolvedQuats(int cubit, int[] numLayers);
       protected abstract int getSolvedFunctionIndex();
       protected abstract ScrambleState[] getScrambleStates();
       protected abstract int getNumStickerTypes(int[] numLayers);
       protected abstract ObjectSticker retSticker(int face);
       protected abstract int getFaceColor(int cubit, int cubitface, int[] numLayers);
       protected abstract int getResource(int[] numLayers);
       protected abstract ObjectType intGetObjectType(int[] numLayers);
       protected abstract Movement getMovement();
       // for JSON only
       public abstract int getSolvedFunctionIndex();
       public abstract int getMovementType();
       public abstract int getMovementSplit();
       public abstract boolean[][] getLayerRotatable(int[] numLayers);
       public abstract int[][][] getEnabled();
       public abstract float[] getDist3D(int[] numLayers);
       public abstract Static3D[] getRotationAxis();
       public abstract int[] getBasicAngle();
       public abstract int getNumFaces();
       public abstract int getObjectName(int[] numLayers);
       public abstract int getInventor(int[] numLayers);
       public abstract int getYearOfInvention(int[] numLayers);
       public abstract int getComplexity(int[] numLayers);
+      }

         return R.string.bandaged_2bar_inventor;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
+        {
         return 2000;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)

         return R.string.bandaged_3plate_inventor;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
+        {
         return 2000;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)

     package org.distorted.objectlib.objects;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_HEXAHEDRON;
     import static org.distorted.objectlib.main.Movement.TYPE_NOT_SPLIT;
     import android.content.res.Resources;
-...
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.main.Movement;
     import org.distorted.objectlib.main.Movement6;
     import org.distorted.objectlib.helpers.ObjectShape;
     import org.distorted.objectlib.helpers.ObjectSticker;
-...
              {2,2,2}
             };
       private static final int[][][] ENABLED = new int[][][]
+          {
               {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}},
           };
       private static final int NUM_STICKERS = 4;
       private int[] mBasicAngle;
-...
       private int[][] mAxisMap;
       private int[][] mFaceMap;
       private float[][] mCuts;
       private boolean[][] mLayerRotatable;
       private Movement mMovement;
       ScrambleState[] mStates;
       float[][] POSITIONS;
       int[] QUAT_INDICES;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void getLayerRotatable(int[] numLayers)
       public boolean[][] getLayerRotatable(int[] numLayers)
+        {
         if( mLayerRotatable==null )
+          {
           int numAxis = ROT_AXIS.length;
           mLayerRotatable = new boolean[numAxis][];
         int numAxis = ROT_AXIS.length;
         boolean[][] layerRotatable = new boolean[numAxis][];
           for(int i=0; i<numAxis; i++)
+            {
             mLayerRotatable[i] = new boolean[numLayers[i]];
             for(int j=0; j<numLayers[i]; j++) mLayerRotatable[i][j] = true;
+            }
         for(int i=0; i<numAxis; i++)
+          {
           layerRotatable[i] = new boolean[numLayers[i]];
           for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;
+          }
         return layerRotatable;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementType()
+        {
         return MOVEMENT_HEXAHEDRON;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementSplit()
+        {
         return TYPE_NOT_SPLIT;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int getSolvedFunctionIndex()
       public int[][][] getEnabled()
+        {
         return new int[][][]
+          {
               {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}},
           };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float[] getDist3D(int[] numLayers)
+        {
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getSolvedFunctionIndex()
+        {
         return 0;
+        }
-...
         return ROT_AXIS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public Movement getMovement()
+        {
         if( mMovement==null )
+          {
           int[] numLayers = getNumLayers();
           if( mCuts==null ) getCuts(numLayers);
           getLayerRotatable(numLayers);
           mMovement = new Movement6(ROT_AXIS,mCuts,mLayerRotatable,numLayers[0],TYPE_NOT_SPLIT,ENABLED);
+          }
         return mMovement;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[] getBasicAngle()

         return R.string.bandaged_evil_inventor;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
+        {
         return 2000;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)

         return R.string.bandaged_fused_inventor;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
+        {
         return 2000;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)

     package org.distorted.objectlib.objects;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_SHAPECHANGE;
     import static org.distorted.objectlib.main.Movement.TYPE_NOT_SPLIT;
     import android.content.res.Resources;
-...
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.R;
     import org.distorted.objectlib.main.Movement;
     import org.distorted.objectlib.main.MovementC;
     import org.distorted.objectlib.main.ObjectControl;
     import org.distorted.objectlib.main.ObjectType;
-...
                new Static3D(0,0,1)
              };
       private static final int[][][] ENABLED = new int[][][]
+          {
               {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}},
           };
       private ScrambleState[] mStates;
       private Static4D[] mQuats;
       private float[][] mCuts;
       private boolean[][] mLayerRotatable;
       private int[] mBasicAngle;
       private ObjectSticker[] mStickers;
       private Movement mMovement;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void getLayerRotatable(int[] numLayers)
       public boolean[][] getLayerRotatable(int[] numLayers)
+        {
         if( mLayerRotatable==null )
+          {
           int numAxis = ROT_AXIS.length;
           mLayerRotatable = new boolean[numAxis][];
         int numAxis = ROT_AXIS.length;
         boolean[][] layerRotatable = new boolean[numAxis][];
           for(int i=0; i<numAxis; i++)
+            {
             mLayerRotatable[i] = new boolean[numLayers[i]];
             for(int j=0; j<numLayers[i]; j++) mLayerRotatable[i][j] = true;
+            }
         for(int i=0; i<numAxis; i++)
+          {
           layerRotatable[i] = new boolean[numLayers[i]];
           for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int getSolvedFunctionIndex()
+        {
         return 0;
         return layerRotatable;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int getNumStickerTypes(int[] numLayers)
       public int getMovementType()
+        {
         return 1;
         return MOVEMENT_SHAPECHANGE;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int getNumCubitFaces()
       public int getMovementSplit()
+        {
         return 6;
         return TYPE_NOT_SPLIT;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
       public Static3D[] getRotationAxis()
       public int[][][] getEnabled()
+        {
         return ROT_AXIS;
         return new int[][][]
+          {
               {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}},
           };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public Movement getMovement()
       public float[] getDist3D(int[] numLayers)
+        {
         if( mMovement==null )
+          {
           int[] numLayers = getNumLayers();
           if( mCuts==null ) getCuts(numLayers);
           getLayerRotatable(numLayers);
           float avg = (numLayers[0]+numLayers[1]+numLayers[2])/3.0f;
         float avg = (numLayers[0]+numLayers[1]+numLayers[2])/3.0f;
           float[] dist3D =
         return new float[]
+            {
 .5f*numLayers[0]/avg,
 .5f*numLayers[0]/avg,
-...
 .5f*numLayers[2]/avg,
 .5f*numLayers[2]/avg,
             };
+        }
           mMovement = new MovementC(ROT_AXIS,mCuts,mLayerRotatable,avg,TYPE_NOT_SPLIT,ENABLED,dist3D);
+          }
         return mMovement;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getSolvedFunctionIndex()
+        {
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int getNumStickerTypes(int[] numLayers)
+        {
         return 1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int getNumCubitFaces()
+        {
         return 6;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
       public Static3D[] getRotationAxis()
+        {
         return ROT_AXIS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         return R.string.cube3_inventor;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
+        {
         switch(numLayers[0])
+          {
           case 2: return 1970;
           case 3: return 1974;
           case 4: return 1981;
           case 5: return 1981;
+          }
         return 1974;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)

     package org.distorted.objectlib.objects;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_OCTAHEDRON;
     import static org.distorted.objectlib.main.Movement.TYPE_NOT_SPLIT;
     import android.content.res.Resources;
-...
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.R;
     import org.distorted.objectlib.main.Movement;
     import org.distorted.objectlib.main.Movement8;
     import org.distorted.objectlib.main.ObjectControl;
     import org.distorted.objectlib.main.ObjectType;
-...
                new Static3D(     0,-SQ3/3,+SQ6/3)
              };
       private static final int[][][] ENABLED = new int[][][]
+          {
               {{1,2,3}},{{1,2,3}},{{0,2,3}},{{0,2,3}},{{0,1,3}},{{0,1,3}},{{0,1,2}},{{0,1,2}}
           };
       private ScrambleState[] mStates;
       private int[] mBasicAngle;
       private int[] mFaceMap;
       private float[][] mCuts;
       private boolean[][] mLayerRotatable;
       private Static4D[] mQuats;
       private int[] mTetraToFaceMap;
       private ObjectSticker[] mStickers;
       private Movement mMovement;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int getSolvedFunctionIndex()
       public int getSolvedFunctionIndex()
+        {
         return 0;
+        }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void getLayerRotatable(int[] numLayers)
       public boolean[][] getLayerRotatable(int[] numLayers)
+        {
         if( mLayerRotatable==null )
+          {
           int numAxis = ROT_AXIS.length;
           mLayerRotatable = new boolean[numAxis][];
         int numAxis = ROT_AXIS.length;
         boolean[][] layerRotatable = new boolean[numAxis][];
           for(int i=0; i<numAxis; i++)
+            {
             mLayerRotatable[i] = new boolean[numLayers[i]];
             for(int j=0; j<numLayers[i]; j++) mLayerRotatable[i][j] = true;
+            }
         for(int i=0; i<numAxis; i++)
+          {
           layerRotatable[i] = new boolean[numLayers[i]];
           for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;
+          }
         return layerRotatable;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementType()
+        {
         return MOVEMENT_OCTAHEDRON;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementSplit()
+        {
         return TYPE_NOT_SPLIT;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[][][] getEnabled()
+        {
         return new int[][][]
+          {
               {{1,2,3}},{{1,2,3}},{{0,2,3}},{{0,2,3}},{{0,1,3}},{{0,1,3}},{{0,1,2}},{{0,1,2}}
           };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float[] getDist3D(int[] numLayers)
+        {
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         return ROT_AXIS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public Movement getMovement()
+        {
         if( mMovement==null )
+          {
           int[] numLayers = getNumLayers();
           if( mCuts==null ) getCuts(numLayers);
           getLayerRotatable(numLayers);
           mMovement = new Movement8(ROT_AXIS,mCuts,mLayerRotatable,numLayers[0],TYPE_NOT_SPLIT,ENABLED);
+          }
         return mMovement;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[] getBasicAngle()
-...
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
+        {
         switch(numLayers[0])
+          {
           case 2: return 1984;
           case 3: return 2003;
           case 4: return 2011;
+          }
         return 1984;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)

     package org.distorted.objectlib.objects;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_HEXAHEDRON;
     import static org.distorted.objectlib.main.Movement.TYPE_SPLIT_CORNER;
     import android.content.res.Resources;
-...
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.R;
     import org.distorted.objectlib.main.Movement;
     import org.distorted.objectlib.main.Movement6;
     import org.distorted.objectlib.helpers.ObjectShape;
     import org.distorted.objectlib.helpers.ObjectSticker;
     import org.distorted.objectlib.helpers.ScrambleState;
-...
                new Static3D(+SQ3/3,-SQ3/3,-SQ3/3)
              };
       private static final int[][][] ENABLED = new int[][][]
+          {
               {{0,1},{3,1},{2,3},{0,2}},
               {{2,3},{3,1},{0,1},{0,2}},
               {{1,2},{0,1},{0,3},{2,3}},
               {{1,2},{2,3},{0,3},{0,1}},
               {{0,3},{0,2},{1,2},{1,3}},
               {{1,2},{0,2},{0,3},{1,3}},
           };
       private int[] mBasicAngle;
       private Static4D[] mQuats;
       private float[][] mCuts;
       private boolean[][] mLayerRotatable;
       private ObjectSticker[] mStickers;
       private float[][] mCenters;
       private Movement mMovement;
       ScrambleState[] mStates;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void getLayerRotatable(int[] numLayers)
       public boolean[][] getLayerRotatable(int[] numLayers)
+        {
         if( mLayerRotatable==null )
         int numAxis = ROT_AXIS.length;
         boolean[] tmp = new boolean[] {true,false,true};
         boolean[][] layerRotatable = new boolean[numAxis][];
         for(int i=0; i<numAxis; i++) layerRotatable[i] = tmp;
         return layerRotatable;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementType()
+        {
         return MOVEMENT_HEXAHEDRON;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementSplit()
+        {
         return TYPE_SPLIT_CORNER;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[][][] getEnabled()
+        {
         return new int[][][]
+          {
           int numAxis = ROT_AXIS.length;
           boolean[] tmp = new boolean[] {true,false,true};
           mLayerRotatable = new boolean[numAxis][];
           for(int i=0; i<numAxis; i++) mLayerRotatable[i] = tmp;
+          }
               {{0,1},{3,1},{2,3},{0,2}},
               {{2,3},{3,1},{0,1},{0,2}},
               {{1,2},{0,1},{0,3},{2,3}},
               {{1,2},{2,3},{0,3},{0,1}},
               {{0,3},{0,2},{1,2},{1,3}},
               {{1,2},{0,2},{0,3},{1,3}},
           };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float[] getDist3D(int[] numLayers)
+        {
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         return ROT_AXIS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public Movement getMovement()
+        {
         if( mMovement==null )
+          {
           int[] numLayers = getNumLayers();
           if( mCuts==null ) getCuts(numLayers);
           getLayerRotatable(numLayers);
           mMovement = new Movement6(ROT_AXIS,mCuts,mLayerRotatable,numLayers[0],TYPE_SPLIT_CORNER,ENABLED);
+          }
         return mMovement;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[] getBasicAngle()

src/main/java/org/distorted/objectlib/objects/TwistyDino4.java
85	85
86	86	///////////////////////////////////////////////////////////////////////////////////////////////////
87	87
88		protected int getSolvedFunctionIndex()
	88	public int getSolvedFunctionIndex()
89	89	{
90	90	return 1;
91	91	}
...	...
117	117	{
118	118	return R.string.din43_inventor;
119	119	}
	120
	121	///////////////////////////////////////////////////////////////////////////////////////////////////
	122
	123	public int getYearOfInvention(int[] numLayers)
	124	{
	125	return 1985;
	126	}
120	127	}

src/main/java/org/distorted/objectlib/objects/TwistyDino6.java
94	94
95	95	///////////////////////////////////////////////////////////////////////////////////////////////////
96	96
97		protected int getSolvedFunctionIndex()
	97	public int getSolvedFunctionIndex()
98	98	{
99	99	return 2;
100	100	}
...	...
119	119	{
120	120	return R.string.dino3_inventor;
121	121	}
	122
	123	///////////////////////////////////////////////////////////////////////////////////////////////////
	124
	125	public int getYearOfInvention(int[] numLayers)
	126	{
	127	return 1985;
	128	}
122	129	}

     package org.distorted.objectlib.objects;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_HEXAHEDRON;
     import static org.distorted.objectlib.main.Movement.TYPE_SPLIT_EDGE;
     import android.content.res.Resources;
-...
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.R;
     import org.distorted.objectlib.main.Movement;
     import org.distorted.objectlib.main.Movement6;
     import org.distorted.objectlib.main.ObjectControl;
     import org.distorted.objectlib.main.ObjectType;
-...
                new Static3D(-SQ2/2, -SQ2/2,      0)
              };
       private static final int[][][] ENABLED = new int[][][]
+          {
               {{2,5},{2,4},{3,4},{3,5}},
               {{2,4},{2,5},{3,5},{3,4}},
               {{0,5},{1,5},{1,4},{0,4}},
               {{0,4},{1,4},{1,5},{0,5}},
               {{1,3},{0,3},{0,2},{1,2}},
               {{0,3},{1,3},{1,2},{0,2}},
           };
       private ScrambleState[] mStates;
       private int[] mBasicAngle;
       private Static4D[] mQuats;
       private float[][] mCuts;
       private boolean[][] mLayerRotatable;
       private float[][] mCenters;
       private int[] mQuatIndices;
       private int[][] mFaceMap;
       private ObjectSticker[] mStickers;
       private Movement mMovement;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int getSolvedFunctionIndex()
       public int getSolvedFunctionIndex()
+        {
         return 0;
+        }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void getLayerRotatable(int[] numLayers)
       public boolean[][] getLayerRotatable(int[] numLayers)
+        {
         int numAxis = ROT_AXIS.length;
         boolean[] tmp = new boolean[] {true,false,true};
         boolean[][] layerRotatable = new boolean[numAxis][];
         for(int i=0; i<numAxis; i++) layerRotatable[i] = tmp;
         return layerRotatable;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementType()
+        {
         return MOVEMENT_HEXAHEDRON;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementSplit()
+        {
         return TYPE_SPLIT_EDGE;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[][][] getEnabled()
+        {
         if( mLayerRotatable==null )
         return new int[][][]
+          {
           int numAxis = ROT_AXIS.length;
           boolean[] tmp = new boolean[] {true,false,true};
           mLayerRotatable = new boolean[numAxis][];
           for(int i=0; i<numAxis; i++) mLayerRotatable[i] = tmp;
+          }
               {{2,5},{2,4},{3,4},{3,5}},
               {{2,4},{2,5},{3,5},{3,4}},
               {{0,5},{1,5},{1,4},{0,4}},
               {{0,4},{1,4},{1,5},{0,5}},
               {{1,3},{0,3},{0,2},{1,2}},
               {{0,3},{1,3},{1,2},{0,2}},
           };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float[] getDist3D(int[] numLayers)
+        {
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         return ROT_AXIS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public Movement getMovement()
+        {
         if( mMovement==null )
+          {
           int[] numLayers = getNumLayers();
           if( mCuts==null ) getCuts(numLayers);
           getLayerRotatable(numLayers);
           mMovement = new Movement6(ROT_AXIS,mCuts,mLayerRotatable,numLayers[0],TYPE_SPLIT_EDGE,ENABLED);
+          }
         return mMovement;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[] getBasicAngle()
-...
         return R.string.heli3_inventor;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
+        {
         return 2006;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)

     package org.distorted.objectlib.objects;
     import static org.distorted.objectlib.main.Movement.TYPE_SPLIT_CORNER;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_HEXAHEDRON;
     import android.content.res.Resources;
-...
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.R;
     import org.distorted.objectlib.main.Movement;
     import org.distorted.objectlib.main.Movement6;
     import org.distorted.objectlib.main.ObjectControl;
     import org.distorted.objectlib.main.ObjectType;
-...
                new Static3D(+SQ3/3,-SQ3/3,-SQ3/3)
              };
       private static final int[][][] ENABLED = new int[][][]
+          {
               {{0},{3},{3},{0}},
               {{2},{1},{1},{2}},
               {{2},{0},{0},{2}},
               {{1},{3},{3},{1}},
               {{0},{0},{1},{1}},
               {{2},{2},{3},{3}},
           };
       private static final int NUM_STICKERS = 2;
       public static final float IVY_D = 0.006f;
       private static final int  IVY_N = 8;
-...
       private int[] mBasicAngle;
       private Static4D[] mQuats;
       private float[][] mCuts;
       private boolean[][] mLayerRotatable;
       private int[][] mFaceMap;
       private ObjectSticker[] mStickers;
       private Movement mMovement;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int getSolvedFunctionIndex()
       public int getSolvedFunctionIndex()
+        {
         return 0;
+        }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void getLayerRotatable(int[] numLayers)
       public boolean[][] getLayerRotatable(int[] numLayers)
+        {
         if( mLayerRotatable==null )
+          {
           int numAxis = ROT_AXIS.length;
           mLayerRotatable = new boolean[numAxis][];
         int numAxis = ROT_AXIS.length;
         boolean[][] layerRotatable = new boolean[numAxis][];
           for(int i=0; i<numAxis; i++)
+            {
             mLayerRotatable[i] = new boolean[numLayers[i]];
             for(int j=0; j<numLayers[i]; j++) mLayerRotatable[i][j] = true;
+            }
         for(int i=0; i<numAxis; i++)
+          {
           layerRotatable[i] = new boolean[numLayers[i]];
           for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;
+          }
         return layerRotatable;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementType()
+        {
         return MOVEMENT_HEXAHEDRON;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementSplit()
+        {
         return TYPE_SPLIT_CORNER;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[][][] getEnabled()
+        {
         return new int[][][]
+          {
               {{0},{3},{3},{0}},
               {{2},{1},{1},{2}},
               {{2},{0},{0},{2}},
               {{1},{3},{3},{1}},
               {{0},{0},{1},{1}},
               {{2},{2},{3},{3}},
           };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float[] getDist3D(int[] numLayers)
+        {
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         return ROT_AXIS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public Movement getMovement()
+        {
         if( mMovement==null )
+          {
           int[] numLayers = getNumLayers();
           if( mCuts==null ) getCuts(numLayers);
           getLayerRotatable(numLayers);
           mMovement = new Movement6(ROT_AXIS,mCuts,mLayerRotatable,numLayers[0],TYPE_SPLIT_CORNER,ENABLED);
+          }
         return mMovement;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[] getBasicAngle()
-...
         return R.string.ivy2_inventor;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
+        {
         return 2009;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)

     package org.distorted.objectlib.objects;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_TETRAHEDRON;
     import static org.distorted.objectlib.main.Movement.TYPE_NOT_SPLIT;
     import android.content.res.Resources;
-...
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.R;
     import org.distorted.objectlib.main.Movement;
     import org.distorted.objectlib.main.Movement4;
     import org.distorted.objectlib.main.ObjectControl;
     import org.distorted.objectlib.main.ObjectType;
-...
                new Static3D(-SQ6/3,+SQ3/3,     0),
              };
       private static final int[][][] ENABLED = new int[][][]
+          {
               {{1,2,3}},{{0,2,3}},{{0,1,3}},{{0,1,2}}
           };
       static final float F = 0.48f;  // length of the edge of the corner cubit. Keep<0.5
                                      // Assuming the length of the edge of the whole
                                      // tetrahedron is 2.0 (ie standard, equal to numLayers
-...
       private int[] mRotQuat;
       private Static4D[] mQuats;
       private float[][] mCuts;
       private boolean[][] mLayerRotatable;
       private float[][] mCenters;
       private int[][] mFaceMap;
       private ObjectSticker[] mStickers;
       private Movement mMovement;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int getSolvedFunctionIndex()
       public int getSolvedFunctionIndex()
+        {
         return 0;
+        }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void getLayerRotatable(int[] numLayers)
       public boolean[][] getLayerRotatable(int[] numLayers)
+        {
         if( mLayerRotatable==null )
+          {
           int numAxis = ROT_AXIS.length;
           mLayerRotatable = new boolean[numAxis][];
         int numAxis = ROT_AXIS.length;
         boolean[][] layerRotatable = new boolean[numAxis][];
           for(int i=0; i<numAxis; i++)
+            {
             mLayerRotatable[i] = new boolean[numLayers[i]];
             for(int j=0; j<numLayers[i]; j++) mLayerRotatable[i][j] = true;
+            }
         for(int i=0; i<numAxis; i++)
+          {
           layerRotatable[i] = new boolean[numLayers[i]];
           for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;
+          }
         return layerRotatable;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementType()
+        {
         return MOVEMENT_TETRAHEDRON;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getMovementSplit()
+        {
         return TYPE_NOT_SPLIT;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[][][] getEnabled()
+        {
         return new int[][][]
+          {
               {{1,2,3}},{{0,2,3}},{{0,1,3}},{{0,1,2}}
           };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float[] getDist3D(int[] numLayers)
+        {
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         return ROT_AXIS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public Movement getMovement()
+        {
         if( mMovement==null )
+          {
           int[] numLayers = getNumLayers();
           if( mCuts==null ) getCuts(numLayers);
           getLayerRotatable(numLayers);
           mMovement = new Movement4(ROT_AXIS,mCuts,mLayerRotatable,numLayers[0],TYPE_NOT_SPLIT,ENABLED);
+          }
         return mMovement;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[] getBasicAngle()
-...
         return R.string.jing_inventor;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
+        {
         return 1991;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)

         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
+        {
         switch(numLayers[0])
+          {
           case 3: return 2008;
           case 5: return 2010;
+          }
         return 2008;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)

         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
+        {
         switch(numLayers[0])
+          {
           case 3: return 1982;
           case 5: return 2006;
+          }
         return 1982;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)

     package org.distorted.objectlib.objects;
     import static org.distorted.objectlib.main.Movement.MOVEMENT_DODECAHEDRON;
     import static org.distorted.objectlib.main.Movement.TYPE_SPLIT_EDGE;
     import static org.distorted.objectlib.main.Movement12.C2;
     import static org.distorted.objectlib.main.Movement12.LEN;
-...
     import org.distorted.library.mesh.MeshSquare;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.main.Movement;
     import org.distorted.objectlib.main.Movement12;
     import org.distorted.objectlib.helpers.ObjectSticker;
     import org.distorted.objectlib.helpers.ScrambleState;
-...
                new Static3D( SIN54/LEN,    0     ,   -C2/LEN )
              };
       private static final int[][][] ENABLED = new int[][][]
+          {
               {{2,3},{3,5},{1,5},{1,4},{2,4}},
               {{0,5},{2,5},{2,3},{3,4},{0,4}},
               {{2,3},{2,5},{0,5},{0,4},{3,4}},
               {{1,5},{3,5},{2,3},{2,4},{1,4}},
               {{0,3},{0,4},{4,5},{1,5},{1,3}},
               {{1,2},{1,4},{4,5},{0,5},{0,2}},
               {{4,5},{1,4},{1,2},{0,2},{0,5}},
               {{4,5},{0,4},{0,3},{1,3},{1,5}},
               {{0,2},{0,1},{1,3},{3,5},{2,5}},
               {{3,4},{2,4},{1,2},{0,1},{0,3}},
               {{2,4},{3,4},{0,3},{0,1},{1,2}},
               {{1,3},{0,1},{0,2},{2,5},{3,5}},
           };
       private ScrambleState[] mStates;
       private int[] mBasicAngle;
       private int[] mFaceMap;
       private float[][] mCuts;
       private boolean[][] mLayerRotatable;

Project

General

Profile

TwistyPuzzleLib

Revision 59c20632

Added by Leszek Koltunski over 2 years ago