/ - Diff - TwistyPuzzleLib - Distorted Android

« Previous | Next »

Revision 8801b933

Added by Leszek Koltunski almost 2 years ago

ID 8801b933002810f56a1829240b1ea609fabf430f
Parent b1370e3b
Child a0b0795b

IAP: finish the 'Purschase' activity.

       private static final int NUM_EFFECTS = PresentEffect.Type.values().length;
       private static final int FAKE_EFFECT_ID  = -6;
       private static final int EXTRA_DURATION = 5000;
       private static final int EXTRA_DURATION = 3000;
       private static final PresentEffect.Type[] types;
       static
-...
+          }
+        }
       private int mEffectReturned;
       private int mNumScramblesLeft;
       private int mDurationPerDegree;
       private final Random mRnd;
       private int[][] mBasicAngle;
       private boolean mRotReady, mPluginReady;
       private boolean mScrambleForward;
       private int mTotalDuration;
       ObjectPreRender mPre;
       TwistyObject mObject;
-...
       Effect[] mCubeEffects;
       int[] mCubeEffectPosition;
       int mCubeEffectNumber, mNodeEffectNumber;
       int mNumScrambles;
       int mNumScrambles, mCurrScramble;
       int[][] mScrambles;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       abstract void createEffects(int duration, int numScrambles);
       abstract void effectFinishedPlugin(final long effectID);
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void createBaseEffects(int duration, int numScrambles)
       private void createBaseEffects(int numScrambles)
+        {
         mNumScrambles = numScrambles;
         mCurrScramble = 0;
         mScrambleForward = true;
         randomizeScrambles();
         addNewScramble();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void randomizeScrambles()
+        {
         mNumScramblesLeft = numScrambles;
         int absAngle, angle, axis, row, basicDegrees, totalDegrees = 0;
         for(int scramble=0; scramble<mNumScramblesLeft; scramble++)
         for(int scramble=0; scramble<mNumScrambles; scramble++)
+          {
           mObject.randomizeNewScramble(mScrambles, mRnd, scramble, numScrambles);
           mObject.randomizeNewScramble(mScrambles, mRnd, scramble, mNumScrambles);
           axis  = mScrambles[scramble][0];
           row   = mScrambles[scramble][1];
           angle = mScrambles[scramble][2];
-...
           totalDegrees += absAngle*basicDegrees;
+          }
         mDurationPerDegree = duration/(2*totalDegrees);
         mNumScrambles = 0;
         mRotReady    = false;
         mPluginReady = false;
         addNewScramble();
         mDurationPerDegree = mTotalDuration/(2*totalDegrees);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void addNewScramble()
+        {
         if( mNumScramblesLeft>0 )
         if( mScrambleForward )
+          {
           addRotation(true);
           if( mCurrScramble==0 )
+            {
             Thread thread = new Thread()
+              {
               public void run()
+                {
                 randomizeScrambles();
                 try { sleep(EXTRA_DURATION); }
                 catch(InterruptedException ex) { }
                 addRotation(true);
+                }
               };
             thread.start();
+            }
           else
+            {
             addRotation(true);
+            }
+          }
         else
+          {
           if( mNumScrambles>0 )
           if( mCurrScramble>=mNumScrambles )
+            {
             if( mNumScramblesLeft==0 )
             Thread thread = new Thread()
+              {
               Thread thread = new Thread()
               public void run()
+                {
                 public void run()
+                  {
                   try { sleep(EXTRA_DURATION); }
                   catch(InterruptedException ex) { }
                   addRotation(false);
+                  }
                 };
               thread.start();
+              }
             else
+              {
               addRotation(false);
+              }
                 try { sleep(EXTRA_DURATION); }
                 catch(InterruptedException ex) { }
                 addRotation(false);
+                }
               };
             thread.start();
+            }
           else
+            {
             mRotReady = true;
             if( mPluginReady ) mPre.effectFinished(FAKE_EFFECT_ID);
             addRotation(false);
+            }
+          }
+        }
-...
       private void addRotation(boolean forward)
+        {
         if( !forward )
+          {
           mNumScrambles--;
           mNumScramblesLeft--;
+          }
         if( !forward ) mCurrScramble--;
         int axis = mScrambles[mNumScrambles][0];
         int row  = mScrambles[mNumScrambles][1];
         int angle= mScrambles[mNumScrambles][2];
         int axis = mScrambles[mCurrScramble][0];
         int row  = mScrambles[mCurrScramble][1];
         int angle= mScrambles[mCurrScramble][2];
         if( !forward ) angle = -angle;
         mPre.addRotation(this, axis, (1<<row), angle, mDurationPerDegree);
         if( forward )
+          {
           mNumScrambles++;
           mNumScramblesLeft--;
+          }
         if( forward ) mCurrScramble++;
         if( mCurrScramble>=mNumScrambles ) mScrambleForward=false;
         if( mCurrScramble<=0             ) mScrambleForward=true;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void disassignEffects()
+        {
         for(int i=0; i<mCubeEffectNumber; i++)
+          {
           mObject.removeEffect(mCubeEffects[i].getID());
+          }
         DistortedEffects nodeEffects = mObjectNode.getEffects();
         for(int i=0; i<mNodeEffectNumber; i++)
+          {
           nodeEffects.abortById(mNodeEffects[i].getID());
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         addNewScramble();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void effectFinishedAction(final long effectID)
+        {
         mEffectReturned++;
         effectFinishedPlugin(effectID);
         if( mEffectReturned == mCubeEffectNumber+mNodeEffectNumber )
+          {
           disassignEffects();
           mPluginReady = true;
           if( mRotReady ) mPre.effectFinished(FAKE_EFFECT_ID);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void effectFinished(final long effectID)
+        {
         for(int i=0; i<mCubeEffectNumber; i++)
+          {
           long id = mCubeEffects[i].getID();
           if( effectID == id )
+            {
             effectFinishedAction(effectID);
             return;
+            }
+          }
         for(int i=0; i<mNodeEffectNumber; i++)
+          {
           long id = mNodeEffects[i].getID();
           if( effectID == id )
+            {
             effectFinishedAction(effectID);
             return;
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         int numScrambles = pre.getNumScrambles();
         mScrambles = new int[numScrambles][3];
         int dura = (int)(duration*Math.pow(numScrambles,0.66f));
         createBaseEffects(dura,numScrambles);
         createEffects    (dura+EXTRA_DURATION,numScrambles);
         mTotalDuration = (int)(duration*Math.pow(numScrambles,0.66f));
         createBaseEffects(numScrambles);
         createEffects(mTotalDuration,numScrambles);
         if( mCubeEffectNumber==0 && mNodeEffectNumber==0 )
+          {

     package org.distorted.objectlib.effects.present;
     import java.util.Random;
     import org.distorted.library.effect.Effect;
     import org.distorted.library.effect.MatrixEffectQuaternion;
     import org.distorted.library.effect.MatrixEffectRotate;
     import org.distorted.library.type.Dynamic;
     import org.distorted.library.type.DynamicQuat;
     import org.distorted.library.type.Dynamic1D;
     import org.distorted.library.type.Static1D;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
     import static org.distorted.library.main.QuatHelper.rotateVectorByInvertedQuat;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     public class PresentEffectSpin extends PresentEffect
+      {
       private final Random mRndGen = new Random(0);
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private Static4D generateNewRandomPoint()
+        {
         float x = mRndGen.nextFloat();
         float y = mRndGen.nextFloat();
         float z = mRndGen.nextFloat();
         float w = mRndGen.nextFloat();
         float len = (float)Math.sqrt(x*x + y*y + z*z + w*w);
         return new Static4D( x/len, y/len, z/len, w/len);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void createEffects(int duration, int numScrambles)
+        {
         mCubeEffectNumber   = 1;
         mNodeEffectNumber   = 0;
         mCubeEffectPosition = new int[] {2};
         mCubeEffectPosition = new int[] {0};
         mCubeEffects        = new Effect[mCubeEffectPosition.length];
         mRndGen.setSeed(System.currentTimeMillis());
         int numRandomPoints = (int)(Math.pow(numScrambles,0.7f));
         DynamicQuat dq = new DynamicQuat(duration, 0.5f);
         dq.setMode(Dynamic.MODE_PATH);
         dq.add(new Static4D(0,0,0,1));
         for(int point=0; point<numRandomPoints; point++)
+          {
           dq.add(generateNewRandomPoint());
+          }
         Static4D quaternion = mObject.getRotationQuat();                      // always rotate around
         Static4D tmpAxis    = new Static4D(0,-1,0,0);                         // vert axis no matter
         Static4D rotated    = rotateVectorByInvertedQuat(tmpAxis,quaternion); // how cube is rotated
         dq.add(new Static4D(0,0,0,1));
         Static3D axis  = new Static3D(rotated.get0(), rotated.get1(), rotated.get2());
         Static3D center= new Static3D(0,0,0);
         mCubeEffects[0] = new MatrixEffectQuaternion(dq, new Static3D(0,0,0));
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void effectFinishedPlugin(final long effectID)
+        {
         Dynamic1D d = new Dynamic1D(duration, 0.0f);
         d.setMode(Dynamic.MODE_JUMP);
         d.setConvexity(0.0f);   // otherwise speed of the rotation would be strangely uneven
         d.add( new Static1D(  0));
         d.add( new Static1D(360));
         mCubeEffects[0] = new MatrixEffectRotate(d,axis,center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff

Project

General

Profile

TwistyPuzzleLib

Revision 8801b933

Added by Leszek Koltunski almost 2 years ago