/ - Diff - TwistyPuzzleLib - Distorted Android

« Previous | Next »

Revision ef2e4213

Added by Leszek Koltunski 6 months ago

ID ef2e42134c47839a99704fa65012d44ab482b7af
Parent 9d215dd2
Child 19dbb227

Correct cuts in the Ghost Pyramid

       private final int mMaxNumLayers;
       private final int mGhostAngle;
       private final int mGhostOrigAxis;
       private final int[] mGhostRowState;
       private Static4D[] mGhostOrigQuat;
       private Static1D[] mGhostEffectAngle;
       private VertexEffectRotate[] mGhostEffect;
       private int[] mGhostOrigCubitRot;
       private int[] mGhostCurrCubitRot;
       private boolean mGhostBlocked;
       private final int[] mRowState;
       private Static4D[] mOrigQuat;
       private Static1D[] mEffectAngle;
       private VertexEffectRotate[] mEffect;
       private int[] mOrigCubitRot;
       private int[] mCurrCubitRot;
       private boolean mBlocked;
       private Static3D mGhostAxis;
       private int mGhostAxisParallelTo;
       private boolean mGhostAxisInverted;
       private int mAxisParallelTo;
       private boolean mAxisInverted;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           if( maxNumLayers<numLayer ) maxNumLayers = numLayer;
         mMaxNumLayers = maxNumLayers;
         mGhostAngle    = controllable.getGhostAngle();
         mGhostAngle = controllable.getGhostAngle();
         mGhostOrigAxis = controllable.getGhostAxis();
         int[] state = controllable.getGhostRowState();
         mGhostRowState = new int[mMaxNumLayers];
         mRowState = new int[mMaxNumLayers];
         if( state!=null )
           for(int i=0; i<mMaxNumLayers; i++) mGhostRowState[i] = state[i];
           for(int i=0; i<mMaxNumLayers; i++) mRowState[i] = state[i];
         if( mGhostAngle!=0 )
         if( mGhostAngle !=0 )
+          {
           mGhostBlocked     = true;
           mGhostAxisInverted= false;
           mBlocked = true;
           mAxisInverted = false;
           mGhostAxis        = new Static3D(mAxis[mGhostOrigAxis]);
           mGhostEffect      = new VertexEffectRotate[mMaxNumLayers];
           mGhostEffectAngle = new Static1D[mMaxNumLayers];
           mGhostOrigQuat    = new Static4D[mMaxNumLayers];
           mEffect = new VertexEffectRotate[mMaxNumLayers];
           mEffectAngle = new Static1D[mMaxNumLayers];
           mOrigQuat = new Static4D[mMaxNumLayers];
           for(int l=0; l<mMaxNumLayers; l++)
+            {
             mGhostEffectAngle[l] = new Static1D(mGhostRowState[l]*mGhostAngle);
             mGhostEffect[l] = new VertexEffectRotate(mGhostEffectAngle[l], mGhostAxis, new Static3D(0, 0, 0));
             effects.apply(mGhostEffect[l]);
             mGhostOrigQuat[l] = computeQuaternion(mGhostOrigAxis,mGhostRowState[l]*mGhostAngle);
             mEffectAngle[l] = new Static1D(mRowState[l]* mGhostAngle);
             mEffect[l] = new VertexEffectRotate(mEffectAngle[l], mGhostAxis, new Static3D(0, 0, 0));
             effects.apply(mEffect[l]);
             mOrigQuat[l] = computeQuaternion(mGhostOrigAxis, mRowState[l]*mGhostAngle);
+            }
           mGhostAxisParallelTo = mGhostOrigAxis;
           mAxisParallelTo = mGhostOrigAxis;
           mGhostOrigCubitRot = new int[mNumCubits];
           mGhostCurrCubitRot = new int[mNumCubits];
           mOrigCubitRot = new int[mNumCubits];
           mCurrCubitRot = new int[mNumCubits];
           reinitializeGhostStuff();
           for(int c=0; c<mNumCubits; c++) mGhostOrigCubitRot[c] = mGhostCurrCubitRot[c];
           for(int c=0; c<mNumCubits; c++) mOrigCubitRot[c] = mCurrCubitRot[c];
+          }
+        }
-...
       public Static4D getCubitGhostQuat(int cubit)
+        {
         if( mGhostAngle!=0 )
         if( mGhostAngle !=0 )
+          {
           int rowBitmap = mObject.getCubitRowBitmap(cubit,mGhostOrigAxis);
           int row = deBitmapize(rowBitmap);
           return mGhostOrigQuat[row];
           return mOrigQuat[row];
+          }
         return null;
-...
       boolean ghostBlocked(int axis)
+        {
         return mGhostBlocked && axis!=mGhostAxisParallelTo;
         return mBlocked && axis!= mAxisParallelTo;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       int nearestGhostAngle(int axis, int row, float angle)
+        {
         if( mGhostAngle!=0 )
         if( mGhostAngle !=0 )
+          {
           int intAngle = (int)angle;
           int basicDeg = 360/mBasicAngles[axis][row];
           int numRot = (int)(angle/basicDeg + 0.5f);
           if( angle< -(basicDeg*0.5) ) numRot -= 1;
           int distToNormalAngle = Math.abs(intAngle-numRot*basicDeg);
           int numRotGhost = (int)(angle/mGhostAngle + 0.5f);
           if( angle< -(mGhostAngle*0.5) ) numRotGhost -= 1;
           int distToGhostAngle = Math.abs(intAngle-numRotGhost*mGhostAngle);
           int numRotGhost = (int)(angle/ mGhostAngle + 0.5f);
           if( angle< -(mGhostAngle *0.5) ) numRotGhost -= 1;
           int distToGhostAngle = Math.abs(intAngle-numRotGhost* mGhostAngle);
           if( distToNormalAngle>distToGhostAngle && (!mGhostBlocked || axis==mGhostAxisParallelTo) )
           if( distToNormalAngle>distToGhostAngle && (!mBlocked || axis== mAxisParallelTo) )
+            {
             int numRows = mBasicAngles[axis].length;
             int thisRow = mGhostRowState[row];
             int thisRow = mRowState[row];
             boolean can1U = (row==numRows-1 || thisRow>=mGhostRowState[row+1]) && (row==0 || thisRow>=mGhostRowState[row-1]);
             boolean can1D = (row==numRows-1 || thisRow<=mGhostRowState[row+1]) && (row==0 || thisRow<=mGhostRowState[row-1]);
             boolean can2U = (row==numRows-1 || thisRow> mGhostRowState[row+1]) && (row==0 || thisRow> mGhostRowState[row-1]);
             boolean can2D = (row==numRows-1 || thisRow< mGhostRowState[row+1]) && (row==0 || thisRow< mGhostRowState[row-1]);
             boolean can1U = (row==numRows-1 || thisRow>=mRowState[row+1]) && (row==0 || thisRow>=mRowState[row-1]);
             boolean can1D = (row==numRows-1 || thisRow<=mRowState[row+1]) && (row==0 || thisRow<=mRowState[row-1]);
             boolean can2U = (row==numRows-1 || thisRow> mRowState[row+1]) && (row==0 || thisRow> mRowState[row-1]);
             boolean can2D = (row==numRows-1 || thisRow< mRowState[row+1]) && (row==0 || thisRow< mRowState[row-1]);
             int maxU = can2U ? -2 : (can1U ? -1 : 0);
             int maxD = can2D ?  2 : (can1D ?  1 : 0);
-...
             if( numRotGhost>maxD ) numRotGhost = maxD;
             if( numRotGhost<maxU ) numRotGhost = maxU;
             return numRotGhost*mGhostAngle;
             return numRotGhost* mGhostAngle;
+            }
+          }
-...
+        {
         int nonGhostAngle = (int)angleInDegrees;
         if( mGhostAngle!=0 && nonGhostAngle!=0 )
         if( mGhostAngle !=0 && nonGhostAngle!=0 )
+          {
           int basicDeg = 360/mBasicAngles[axis][0];
           if( (nonGhostAngle%basicDeg)==0 )
+            {
             if( mGhostBlocked && axis!=mGhostAxisParallelTo ) computeNewGhostAxis(axis,angleInDegrees);
             if( mBlocked && axis!= mAxisParallelTo) computeNewGhostAxis(axis,angleInDegrees);
             return nonGhostAngle;
+            }
-...
           for(int m=1; m<3; m++)
+            {
             if( ((nonGhostAngle+m*mGhostAngle)%basicDeg)==0 ) { move = m; break; }
             if( ((nonGhostAngle-m*mGhostAngle)%basicDeg)==0 ) { move =-m; break; }
             if( ((nonGhostAngle+m* mGhostAngle)%basicDeg)==0 ) { move = m; break; }
             if( ((nonGhostAngle-m* mGhostAngle)%basicDeg)==0 ) { move =-m; break; }
+            }
           nonGhostAngle += move*mGhostAngle;
           nonGhostAngle += move* mGhostAngle;
           if( !mGhostBlocked || axis==mGhostAxisParallelTo )
           if( !mBlocked || axis== mAxisParallelTo)
+            {
             if( mGhostAxisParallelTo!=axis )
             if( mAxisParallelTo !=axis )
+              {
               mGhostAxis.set(mAxis[axis]);
               mGhostAxisParallelTo = axis;
               mGhostAxisInverted   = false;
               mAxisParallelTo = axis;
               mAxisInverted = false;
               for(int l=0; l<mMaxNumLayers; l++)
                 mGhostEffect[l].setMeshAssociation( 1<<(mGhostAxisParallelTo*mMaxNumLayers + l), -1);
                 mEffect[l].setMeshAssociation( 1<<(mAxisParallelTo *mMaxNumLayers + l), -1);
+              }
             int m = mGhostAxisInverted ? -1 : 1;
             boolean oldBlocked = mGhostBlocked;
             mGhostBlocked = false;
             int m = mAxisInverted ? -1 : 1;
             boolean oldBlocked = mBlocked;
             mBlocked = false;
             for(int r=0; r<mMaxNumLayers; r++)
+              {
               if( ((rowBitmap>>r)&0x1) != 0 )
+                {
                 mGhostRowState[r] -= move;
                 mGhostEffectAngle[r].set( m*mGhostRowState[r]*mGhostAngle);
                 mRowState[r] -= move;
                 mEffectAngle[r].set( m* mRowState[r]*mGhostAngle);
+                }
               if( mGhostRowState[r] != mGhostRowState[0] ) mGhostBlocked = true;
               if( mRowState[r] != mRowState[0] ) mBlocked = true;
+              }
             if( oldBlocked && !mGhostBlocked ) computeNewRotationAxis(axis);
             if( oldBlocked && !mBlocked) computeNewRotationAxis(axis);
+            }
+          }
-...
       boolean ghostNotSolved()
+        {
         if( mGhostAngle!=0 )
         if( mGhostAngle !=0 )
+          {
           int first=mGhostCurrCubitRot[0]-mGhostOrigCubitRot[0];
           int first= mCurrCubitRot[0]- mOrigCubitRot[0];
           for( int c=1; c<mNumCubits; c++ )
             if( mGhostCurrCubitRot[c]-mGhostOrigCubitRot[c] != first ) return true;
             if( mCurrCubitRot[c]- mOrigCubitRot[c] != first ) return true;
+          }
         return false;
-...
       void solve()
+        {
         if( mGhostAngle!=0 )
         if( mGhostAngle !=0 )
+          {
           mGhostAxis.set(mAxis[mGhostOrigAxis]);
           mGhostAxisParallelTo = mGhostOrigAxis;
           mGhostAxisInverted   = false;
           mAxisParallelTo = mGhostOrigAxis;
           mAxisInverted = false;
           int[] state = mObject.getGhostRowState();
           if( state!=null )
             for(int i=0; i<mMaxNumLayers; i++) mGhostRowState[i] = state[i];
             for(int i=0; i<mMaxNumLayers; i++) mRowState[i] = state[i];
           reinitializeGhostStuff();
+          }
-...
       void restoreGhostStuff(String key, OperatingSystemInterface os)
+        {
         if( mGhostAngle!=0 )
         if( mGhostAngle !=0 )
+          {
           int defAxis   = mObject.getGhostAxis();
           int[] defState= mObject.getGhostRowState();
           int m                = os.getInt(key+"_ghostInverted",1);
           mGhostAxisParallelTo = os.getInt(key + "_ghostAxis", defAxis);
           for(int l=0; l<mMaxNumLayers; l++) mGhostRowState[l] = os.getInt(key + "_ghostBitmap"+l, defState!=null ? defState[l] : 0 );
           Static3D axis = mAxis[mGhostAxisParallelTo];
           mAxisParallelTo = os.getInt(key + "_ghostAxis", defAxis);
           for(int l=0; l<mMaxNumLayers; l++) mRowState[l] = os.getInt(key + "_ghostBitmap"+l, defState!=null ? defState[l] : 0 );
           Static3D axis = mAxis[mAxisParallelTo];
           mGhostAxis.set(m*axis.get0(),m*axis.get1(), m*axis.get2());
           mGhostAxisInverted = (m==-1);
           mAxisInverted = (m==-1);
           reinitializeGhostStuff();
+          }
-...
       void saveGhostStuff(String key, OperatingSystemInterface os)
+        {
         if( mGhostAngle!=0 )
         if( mGhostAngle !=0 )
+          {
           os.putInt(key + "_ghostInverted", mGhostAxisInverted ? -1 : 1);
           os.putInt(key + "_ghostAxis", mGhostAxisParallelTo);
           for(int l=0; l<mMaxNumLayers; l++) os.putInt(key + "_ghostBitmap"+l, mGhostRowState[l]);
           os.putInt(key + "_ghostInverted", mAxisInverted ? -1 : 1);
           os.putInt(key + "_ghostAxis", mAxisParallelTo);
           for(int l=0; l<mMaxNumLayers; l++) os.putInt(key + "_ghostBitmap"+l, mRowState[l]);
+          }
+        }
-...
       void removeGhostStuff(String key, OperatingSystemInterface os)
+        {
         if( mGhostAngle!=0 )
         if( mGhostAngle !=0 )
+          {
           os.remove(key + "_ghostInverted");
           os.remove(key + "_ghostAxis");
-...
       private boolean isAxisInverted()
+        {
         Static3D a = mAxis[mGhostAxisParallelTo];
         Static3D a = mAxis[mAxisParallelTo];
         float x = mGhostAxis.get0();
         float y = mGhostAxis.get1();
         float z = mGhostAxis.get2();
-...
       private void reinitializeGhostStuff()
+        {
         if( mGhostAngle!=0 )
         if( mGhostAngle !=0 )
+          {
           mGhostBlocked=false;
           mBlocked =false;
           for( int r=0; r<mMaxNumLayers; r++ )
+            {
             mGhostEffectAngle[r].set(mGhostRowState[r]*mGhostAngle);
             mGhostEffect[r].setMeshAssociation(1<<(mGhostAxisParallelTo*mMaxNumLayers + r), -1);
             if( mGhostRowState[r] != mGhostRowState[0] ) mGhostBlocked = true;
             mEffectAngle[r].set(mRowState[r]* mGhostAngle);
             mEffect[r].setMeshAssociation(1<<(mAxisParallelTo *mMaxNumLayers + r), -1);
             if( mRowState[r] != mRowState[0] ) mBlocked = true;
+            }
           computeGhostCubitRotated();
-...
       private void computeGhostCubitRotated()
+        {
         if( mGhostAngle!=0 )
         if( mGhostAngle !=0 )
           for(int c=0; c<mNumCubits; c++)
+            {
             int rowBitmap = mObject.getCubitRowBitmap(c,mGhostAxisParallelTo);
             int rowBitmap = mObject.getCubitRowBitmap(c, mAxisParallelTo);
             int row = deBitmapize(rowBitmap);
             mGhostCurrCubitRot[c] = mGhostRowState[row];
             mCurrCubitRot[c] = mRowState[row];
+            }
+        }
-...
         QuatHelper.rotateVectorByQuat(tmp,x,y,z,0,quat);
         mGhostAxisParallelTo = pullTowardsExistingAxis(tmp);
         mAxisParallelTo = pullTowardsExistingAxis(tmp);
         mGhostAxis.set(tmp[0],tmp[1],tmp[2]);
         boolean wasInverted = mGhostAxisInverted;
         mGhostAxisInverted = isAxisInverted();
         boolean wasInverted = mAxisInverted;
         mAxisInverted = isAxisInverted();
         if( wasInverted^mGhostAxisInverted )
         if( wasInverted^ mAxisInverted)
+          {
           int len = mGhostRowState.length;
           int len = mRowState.length;
           int num = len/2;
           int m = mGhostAxisInverted ? -1 : 1;
           int m = mAxisInverted ? -1 : 1;
           for(int i=0; i<num; i++)
+            {
             int e = len-1-i;
             int t = mGhostRowState[e];
             mGhostRowState[e] = -mGhostRowState[i];
             mGhostRowState[i] = -t;
             int t = mRowState[e];
             mRowState[e] = -mRowState[i];
             mRowState[i] = -t;
             mGhostEffectAngle[e].set( m*mGhostRowState[e]*mGhostAngle);
             mGhostEffectAngle[i].set( m*mGhostRowState[i]*mGhostAngle);
             mEffectAngle[e].set( m* mRowState[e]* mGhostAngle);
             mEffectAngle[i].set( m* mRowState[i]* mGhostAngle);
+            }
           if( (len%2)==1 )
+            {
             int index = (len-1)/2;
             mGhostRowState[index] *= -1;
             mGhostEffectAngle[index].set(m*mGhostRowState[index]*mGhostAngle);
             mRowState[index] *= -1;
             mEffectAngle[index].set(m* mRowState[index]* mGhostAngle);
+            }
+          }
         for(int l=0; l<mMaxNumLayers; l++)
           mGhostEffect[l].setMeshAssociation( 1<<(mGhostAxisParallelTo*mMaxNumLayers + l), -1);
           mEffect[l].setMeshAssociation( 1<<(mAxisParallelTo *mMaxNumLayers + l), -1);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       private void computeNewRotationAxis(int axis)
+        {
         int newLevel = mGhostRowState[0];
         int newLevel = mRowState[0];
         if( newLevel!=0 )
+          {
           Static4D quat = computeQuaternion(axis,newLevel*mGhostAngle);
           Static4D quat = computeQuaternion(axis,newLevel* mGhostAngle);
           mObject.rotateCameraQuat(quat);
           int len = mGhostRowState.length;
           int len = mRowState.length;
           for(int s=0; s<len; s++)
+            {
             mGhostRowState[s] = 0;
             mGhostEffectAngle[s].set(0);
             mRowState[s] = 0;
             mEffectAngle[s].set(0);
+            }
+          }
+        }

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       @Override public int getGhostAngle()
+        {
         return 30;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       @Override public int[] getColorTable()
+        {
         return FACE_COLORS;
+        }
       @Override public int getGhostAngle()      { return 60; }
       @Override public int[] getColorTable()    { return FACE_COLORS; }
       @Override public int[] getGhostRowState() { return new int[] { 1,0 }; }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float[] getPlanesVector()
+        {
         if( mPlanesVector==null ) mPlanesVector = new float[] {0.05f,0.07f,0.09f};
         if( mPlanesVector==null )
+          {
           Static3D axis = ROT_AXIS[0];
           final float A = 0.07f;
           mPlanesVector = new float[] { A*axis.get0(), A*axis.get1(), A*axis.get2() };
+          }
         return mPlanesVector;
+        }
-...
       Static4D getPlanesQuat()
+        {
         Static3D axis1 = new Static3D(0,0,1);
         int angle1 = 30;
         Static3D axis2 = new Static3D(0,1,0);
         int angle2 = 30;
         Static3D axis1 = new Static3D(0,-SQ6/3,SQ3/3);
         int angle1 = -5;
         Static3D axis2 = new Static3D(1,0,0);
         int angle2 = 22;
         Static4D quat1 = makeQuat(axis1,angle1);
         Static4D quat2 = makeQuat(axis2,angle2);
-...
       Static3D[] getOriginalRotationAxis() { return ROT_AXIS; }
       int getBasicAngle()                  { return 3; }
       float[] getCornerPressStrength()     { return new float[] {0.03f,0.15f}; };
       float[] getCornerPressStrength()     { return new float[] {0.02f,0.10f}; };
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        {
         if( mCuts==null )
+          {
           final float F = -0.03f;
           final float F = -0.00f;
           float[] cut =  new float[] { F*(SQ6/3) };
           mCuts = new float[][] { cut,cut,cut,cut };
+          }
-...
       public float getStickerRadius()
+        {
         return 0.06f;
         return 0.05f;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float getStickerStroke()
+        {
         return isInIconMode() ? 0.13f : 0.07f;
         return isInIconMode() ? 0.10f : 0.05f;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff

Project

General

Profile

TwistyPuzzleLib

Revision ef2e4213

Added by Leszek Koltunski 6 months ago