/src/main/java/org/distorted/objectlib/effects/scramble/ScrambleEffect.java - Annotate - TwistyPuzzleLib - Distorted Android

distorted-objectlib / src / main / java / org / distorted / objectlib / effects / scramble / ScrambleEffect.java @ c0266cb1

-            a5a52e8d
+///////////////////////////////////////////////////////////////////////////////////////////////////
 // Copyright 2019 Leszek Koltunski                                                               //
 //                                                                                               //
 // This file is part of Magic Cube.                                                              //
 //                                                                                               //
-ec1348c
+// Magic Cube is proprietary software licensed under an EULA which you should have received      //
 // along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //
-            a5a52e8d
+///////////////////////////////////////////////////////////////////////////////////////////////////
 package org.distorted.objectlib.effects.scramble;
 import java.lang.reflect.Method;
 import java.util.Random;
 import org.distorted.library.effect.Effect;
 import org.distorted.library.main.DistortedEffects;
 import org.distorted.library.message.EffectListener;
-            ecf3d6e3
+import org.distorted.objectlib.main.ObjectPreRender;
-            a5a52e8d
+import org.distorted.objectlib.main.TwistyObject;
 import org.distorted.objectlib.effects.BaseEffect;
 import org.distorted.objectlib.helpers.MovesFinished;
-ba38dd4
+import org.distorted.objectlib.main.TwistyObjectNode;
-            a5a52e8d
+            Leszek Koltunski
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 public abstract class ScrambleEffect extends BaseEffect implements EffectListener, MovesFinished
+{
   public enum Type
+    {
     NONE         (ScrambleEffectNone.class        ),
     ROTATIONS    (ScrambleEffectRotations.class   ),
+    ;
     final Class<? extends ScrambleEffect> effect;
     Type(Class<? extends ScrambleEffect> effect)
+      {
       this.effect= effect;
+      }
+    }
   private static final int NUM_EFFECTS = Type.values().length;
   private static final int FAKE_EFFECT_ID  = -3;
   private static final Type[] types;
   static
+    {
     int i=0;
     types = new Type[NUM_EFFECTS];
     for(Type type: Type.values())
+      {
       types[i++] = type;
+      }
+    }
   private int mEffectReturned;
   private int mNumScramblesLeft;
-df35810
+  private int mDurationPerDegree;
-            a5a52e8d
+  private final Random mRnd;
-            beee90ab
+  private int[][] mBasicAngle;
-            a5a52e8d
+  private boolean mRotReady, mPluginReady;
-d80fe6
+  ObjectPreRender mPre;
-            a5a52e8d
+  TwistyObject mObject;
-ba38dd4
+  TwistyObjectNode mObjectNode;
-            a5a52e8d
+  Effect[] mNodeEffects;
   int[] mNodeEffectPosition;
   Effect[] mCubeEffects;
   int[] mCubeEffectPosition;
   int mCubeEffectNumber, mNodeEffectNumber;
   int mNumScrambles;
   int[][] mScrambles;
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   ScrambleEffect()
+    {
     mRnd = new Random( System.currentTimeMillis() );
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   abstract void createEffects(int duration, int numScrambles);
   abstract void effectFinishedPlugin(final long effectID);
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private void createBaseEffects(int duration, int numScrambles)
+    {
     mNumScramblesLeft = numScrambles;
-            beee90ab
+    int absAngle, angle, axis, row, basicDegrees, totalDegrees = 0;
-            a5a52e8d
+            Leszek Koltunski
     for(int scramble=0; scramble<mNumScramblesLeft; scramble++)
+      {
       mObject.randomizeNewScramble(mScrambles, mRnd, scramble, numScrambles);
-            c0266cb1
+      int[] s = mScrambles[scramble];
       axis  = s[0];
       row   = s[1];
       angle = s[2];
-            a5a52e8d
+      absAngle = (angle<0 ? -angle : angle);
-            beee90ab
+      basicDegrees = 360/mBasicAngle[axis][row];
-            a5a52e8d
+      totalDegrees += absAngle*basicDegrees;
+      }
-            c0266cb1
+    // tablebase scrambling can return a scramble which is shorter than requested,
     // padding the end with three 0s. Take note of that.
     for(int scramble=0; scramble<mNumScramblesLeft; scramble++)
+      {
       int[] s = mScrambles[scramble];
       if( s[0]==0 && s[1]==0 && s[2]==0 ) mNumScramblesLeft = scramble;
+      }
-            a5a52e8d
+    mDurationPerDegree = duration/totalDegrees;
     mNumScrambles = 0;
     mRotReady    = false;
     mPluginReady = false;
     addNewScramble();
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private void addNewScramble()
+    {
     if( mNumScramblesLeft>0 )
+      {
       int axis = mScrambles[mNumScrambles][0];
       int row  = mScrambles[mNumScrambles][1];
       int angle= mScrambles[mNumScrambles][2];
       mNumScramblesLeft--;
-            ecf3d6e3
+      mPre.addRotation(this, axis, (1<<row), angle, mDurationPerDegree);
-            a5a52e8d
+      mNumScrambles++;
+      }
     else
+      {
       mRotReady = true;
-            ecf3d6e3
+      if( mPluginReady ) mPre.effectFinished(FAKE_EFFECT_ID);
-            a5a52e8d
+            Leszek Koltunski
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private void assignEffects()
+    {
     for(int i=0; i<mCubeEffectNumber; i++)
+      {
-d293e
+      mObject.applyEffect(mCubeEffects[i],mCubeEffectPosition[i]);
-            a5a52e8d
+      mCubeEffects[i].notifyWhenFinished(this);
+      }
-ba38dd4
+    DistortedEffects nodeEffects = mObjectNode.getEffects();
-            a5a52e8d
+            Leszek Koltunski
     for(int i=0; i<mNodeEffectNumber; i++)
+      {
       nodeEffects.apply(mNodeEffects[i],mNodeEffectPosition[i]);
       mNodeEffects[i].notifyWhenFinished(this);
+      }
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   private void disassignEffects()
+    {
     for(int i=0; i<mCubeEffectNumber; i++)
+      {
-d293e
+      mObject.removeEffect(mCubeEffects[i].getID());
-            a5a52e8d
+            Leszek Koltunski
-ba38dd4
+    DistortedEffects nodeEffects = mObjectNode.getEffects();
-            a5a52e8d
+            Leszek Koltunski
     for(int i=0; i<mNodeEffectNumber; i++)
+      {
       nodeEffects.abortById(mNodeEffects[i].getID());
+      }
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   @SuppressWarnings("unused")
   public static String[] getNames()
+    {
     String[] names = new String[NUM_EFFECTS];
     for( int i=0; i<NUM_EFFECTS; i++)
+      {
       names[i] = types[i].name();
+      }
     return names;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   @SuppressWarnings("unused")
   public static ScrambleEffect create(int ordinal) throws InstantiationException, IllegalAccessException
+    {
     return types[ordinal].effect.newInstance();
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public void onActionFinished(final long effectID)
+    {
     addNewScramble();
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-cc61ae4
+  private void effectFinishedAction(final long effectID)
-            a5a52e8d
+            Leszek Koltunski
     mEffectReturned++;
     effectFinishedPlugin(effectID);
     if( mEffectReturned == mCubeEffectNumber+mNodeEffectNumber )
+      {
       disassignEffects();
       mPluginReady = true;
-            ecf3d6e3
+      if( mRotReady ) mPre.effectFinished(FAKE_EFFECT_ID);
-            a5a52e8d
+            Leszek Koltunski
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   public void effectFinished(final long effectID)
+    {
     for(int i=0; i<mCubeEffectNumber; i++)
+      {
       long id = mCubeEffects[i].getID();
       if( effectID == id )
+        {
-cc61ae4
+        effectFinishedAction(effectID);
-            a5a52e8d
+        return;
+        }
+      }
     for(int i=0; i<mNodeEffectNumber; i++)
+      {
       long id = mNodeEffects[i].getID();
       if( effectID == id )
+        {
-cc61ae4
+        effectFinishedAction(effectID);
-            a5a52e8d
+        return;
+        }
+      }
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   @SuppressWarnings("unused")
-ba38dd4
+  public long start(int duration, ObjectPreRender pre)
-            a5a52e8d
+            Leszek Koltunski
-ba38dd4
+    mObject     = pre.getObject();
     mObjectNode = pre.getObjectNode();
     mPre        = pre;
-            a5a52e8d
+            Leszek Koltunski
     // NOT mController.solve() !! This would be a very subtle bug. We need to do this immediately,
     // because here we are already inside the mController.preRender() function (doing 'scrambleObjectNow')
     // and doing a delayed 'solve()' here would mean we'd be sometimes first doing the first rotation,
     // and only after it - the solve.
     mObject.solve();
-fe251
+    mBasicAngle = mObject.getBasicAngles();
-            a5a52e8d
+            Leszek Koltunski
-            ecf3d6e3
+    int numScrambles = pre.getNumScrambles();
-cc61ae4
+    mScrambles = new int[numScrambles][3];
-            a5a52e8d
+    int dura = (int)(duration*Math.pow(numScrambles,0.66f));
     createBaseEffects(dura,numScrambles);
     createEffects    (dura,numScrambles);
     if( mCubeEffectNumber==0 && mNodeEffectNumber==0 )
+      {
       throw new RuntimeException("Cube and Node Plugin Effects not created!");
+      }
     assignEffects();
     return FAKE_EFFECT_ID;
+    }
 ///////////////////////////////////////////////////////////////////////////////////////////////////
   @SuppressWarnings("unused")
   public static void enableEffects()
+    {
     Method method;
     for(Type type: Type.values())
+      {
       try
+        {
         method = type.effect.getDeclaredMethod("enable"); // enable not public, thus getDeclaredMethod
+        }
       catch(NoSuchMethodException ex)
+        {
         android.util.Log.e("ScrambleEffect", type.effect.getSimpleName()+": exception getting method: "+ex.getMessage());
         method = null;
+        }
       try
+        {
         if( method!=null ) method.invoke(null);
+        }
       catch(Exception ex)
+        {
         android.util.Log.e("ScrambleEffect", type.effect.getSimpleName()+": exception invoking method: "+ex.getMessage());
+        }
+      }
+    }
+}

Project

General

Profile

TwistyPuzzleLib

distorted-objectlib / src / main / java / org / distorted / objectlib / effects / scramble / ScrambleEffect.java @ c0266cb1