/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision a62aa9d7

Added by Leszek Koltunski about 5 years ago

ID a62aa9d7d063e454b75201df2bb9fc7737c4015b
Parent 3b12e641
Child 30b68322

Progress with ScrambleEffects

       public enum Type
+        {
         NONE         (ScrambleEffectNone.class        ),
         ROTATIONS    (ScrambleEffectRotations.class   ),
+        ;
         final Class<? extends ScrambleEffect> effect;
-...
+        }
       private static int NUM_EFFECTS = Type.values().length;
       private static final int NUM_PHASES  = 2;
       private static final int FAKE_EFFECT_ID  = -3;
       private static final Type[] types;
-...
       private EffectListener mListener;
       private int mDuration;
       private int mEffectReturned;
       private int[] mCubeEffectNumber, mNodeEffectNumber;
       private int mPhase;
       private int[] mEffectReturned;
       private RubikCube mCube;
       private DistortedScreen mScreen;
       static final int EFFECT_FLAVOUR_BASE  = 0;
       static final int EFFECT_FLAVOUR_PLUGIN= 1;
       static final int NUM_EFFECT_FLAVOURS  = 2;
       Effect[][] mNodeEffects;
       int[][] mNodeEffectPosition;
       Effect[][] mCubeEffects;
       int[][] mCubeEffectPosition;
       int[] mCubeEffectNumber, mNodeEffectNumber;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       ScrambleEffect()
+        {
         mPhase = 0;
         mCubeEffectNumber   = new int[NUM_PHASES];
         mNodeEffectNumber   = new int[NUM_PHASES];
         mCubeEffectPosition = new int[NUM_PHASES][];
         mNodeEffectPosition = new int[NUM_PHASES][];
         mCubeEffects        = new Effect[NUM_PHASES][];
         mNodeEffects        = new Effect[NUM_PHASES][];
         mEffectReturned     = new int[NUM_EFFECT_FLAVOURS];
         mCubeEffectNumber   = new int[NUM_EFFECT_FLAVOURS];
         mNodeEffectNumber   = new int[NUM_EFFECT_FLAVOURS];
         mCubeEffectPosition = new int[NUM_EFFECT_FLAVOURS][];
         mNodeEffectPosition = new int[NUM_EFFECT_FLAVOURS][];
         mCubeEffects        = new Effect[NUM_EFFECT_FLAVOURS][];
         mNodeEffects        = new Effect[NUM_EFFECT_FLAVOURS][];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       abstract void createEffectsPhase0(int duration);
       abstract void createEffectsPhase1(int duration);
       abstract void createEffects(int duration);
       abstract void effectFinishedPlugin(final long effectID);
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void effectFinished(final long effectID)
     // TODO
       private void createBaseEffects(int duration, int numScrambles)
+        {
         int total = mCubeEffectNumber[mPhase]+mNodeEffectNumber[mPhase];
         mCubeEffectNumber[EFFECT_FLAVOUR_BASE] = 0;
         mNodeEffectNumber[EFFECT_FLAVOUR_BASE] = 0;
+        }
         for(int i=0; i<mCubeEffectNumber[mPhase]; i++)
+          {
           long id = mCubeEffects[mPhase][i].getID();
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TODO
           if( effectID == id )
+            {
             if( ++mEffectReturned == total ) effectAction(mPhase);
             mCube.remove(id);
             return;
+            }
+          }
         for(int i=0; i<mNodeEffectNumber[mPhase]; i++)
+          {
           long id = mNodeEffects[mPhase][i].getID();
       private void effectFinishedBase(final long effectID)
+        {
           if( effectID == id )
+            {
             if( ++mEffectReturned == total ) effectAction(mPhase);
             mCube.getEffects().abortById(id);
             return;
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void effectAction(int phase)
       public void effectFinished(final long effectID)
+        {
         switch(phase)
         for(int flavour=0; flavour<NUM_EFFECT_FLAVOURS; flavour++)
+          {
           case 0: mEffectReturned = 0;
                   mPhase          = 1;
                   mCube.unscramble();
                   createEffectsPhase1(mDuration);
                   assignEffects(mPhase);
                   break;
           case 1: mListener.effectFinished(FAKE_EFFECT_ID);
                   break;
           for(int i=0; i<mCubeEffectNumber[flavour]; i++)
+            {
             long id = mCubeEffects[flavour][i].getID();
             if( effectID == id )
+              {
               mEffectReturned[flavour]++;
               switch(flavour)
+                {
                 case EFFECT_FLAVOUR_BASE  : effectFinishedBase(  effectID); break;
                 case EFFECT_FLAVOUR_PLUGIN: effectFinishedPlugin(effectID); break;
+                }
               if( mEffectReturned[flavour] == mCubeEffectNumber[flavour]+mNodeEffectNumber[flavour] )
+                {
                 disassignEffects(flavour);
+                }
               return;
+              }
+            }
           for(int i=0; i<mNodeEffectNumber[flavour]; i++)
+            {
             long id = mNodeEffects[flavour][i].getID();
             if( effectID == id )
+              {
               mEffectReturned[flavour]++;
               switch(flavour)
+                {
                 case EFFECT_FLAVOUR_BASE  : effectFinishedBase(  effectID); break;
                 case EFFECT_FLAVOUR_PLUGIN: effectFinishedPlugin(effectID); break;
+                }
               if( mEffectReturned[flavour] == mCubeEffectNumber[flavour]+mNodeEffectNumber[flavour] )
+                {
                 disassignEffects(flavour);
+                }
               return;
+              }
+            }
+          }
+        }
-...
         mListener = listener;
         mDuration = duration;
         createEffectsPhase0(mDuration);
         assignEffects(mPhase);
         createBaseEffects(mDuration, numScrambles);
         assignEffects(EFFECT_FLAVOUR_BASE);
         createEffects(mDuration);
         if( mCubeEffectNumber[EFFECT_FLAVOUR_PLUGIN]==0 && mNodeEffectNumber[EFFECT_FLAVOUR_PLUGIN]==0 )
+          {
           throw new RuntimeException("Cube and Node Plugin Effects not created!");
+          }
         assignEffects(EFFECT_FLAVOUR_PLUGIN);
         return FAKE_EFFECT_ID;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void assignEffects(int phase)
       private void assignEffects(int flavour)
+        {
         mCubeEffectNumber[phase] = ( mCubeEffects[phase]!=null ) ? mCubeEffects[phase].length : 0;
         mNodeEffectNumber[phase] = ( mNodeEffects[phase]!=null ) ? mNodeEffects[phase].length : 0;
         for(int i=0; i<mCubeEffectNumber[flavour]; i++)
+          {
           android.util.Log.e("scramble", "applying cube effect "+mCubeEffects[flavour][i].getName());
           mCube.apply(mCubeEffects[flavour][i],mCubeEffectPosition[flavour][i]);
           mCubeEffects[flavour][i].notifyWhenFinished(this);
+          }
         DistortedEffects nodeEffects = mCube.getEffects();
         if( mCubeEffectNumber[phase]==0 && mNodeEffectNumber[phase]==0 )
         for(int i=0; i<mNodeEffectNumber[flavour]; i++)
+          {
           throw new RuntimeException("Cube and Node Effects ("+phase+" phase) both not created!");
           nodeEffects.apply(mNodeEffects[flavour][i],mNodeEffectPosition[flavour][i]);
           mNodeEffects[flavour][i].notifyWhenFinished(this);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         for(int i=0; i<mCubeEffectNumber[phase]; i++)
       private void disassignEffects(int flavour)
+        {
         for(int i=0; i<mCubeEffectNumber[flavour]; i++)
+          {
           mCube.apply(mCubeEffects[phase][i],mCubeEffectPosition[phase][i]);
           mCubeEffects[phase][i].notifyWhenFinished(this);
           android.util.Log.e("scramble", "removing cube effect "+mCubeEffects[flavour][i].getName());
           mCube.remove(mCubeEffects[flavour][i].getID());
+          }
         DistortedEffects nodeEffects = mCube.getEffects();
         for(int i=0; i<mNodeEffectNumber[phase]; i++)
         for(int i=0; i<mNodeEffectNumber[flavour]; i++)
+          {
           nodeEffects.abortById(mNodeEffects[flavour][i].getID());
+          }
         if( flavour==EFFECT_FLAVOUR_PLUGIN )
+          {
           nodeEffects.apply(mNodeEffects[phase][i],mNodeEffectPosition[phase][i]);
           mNodeEffects[phase][i].notifyWhenFinished(this);
           mListener.effectFinished(FAKE_EFFECT_ID);
+          }
+        }

     public class ScrambleEffectNone extends ScrambleEffect
+      {
       public void createEffectsPhase0(int duration)
       public void createEffects(int duration)
+        {
         Dynamic3D d0 = new Dynamic3D(1,0.5f);
         d0.add(new Static3D(0,0,0));
         mCubeEffectPosition[0] = new int[] {-1};
         mCubeEffects[0]        = new Effect[mCubeEffectPosition[0].length];
         mCubeEffects[0][0]     = new MatrixEffectMove(d0);
         mCubeEffectNumber[EFFECT_FLAVOUR_PLUGIN]   = 1;
         mNodeEffectNumber[EFFECT_FLAVOUR_PLUGIN]   = 0;
         mCubeEffectPosition[EFFECT_FLAVOUR_PLUGIN] = new int[] {-1};
         mCubeEffects[EFFECT_FLAVOUR_PLUGIN]        = new Effect[mCubeEffectPosition[EFFECT_FLAVOUR_PLUGIN].length];
         mCubeEffects[EFFECT_FLAVOUR_PLUGIN][0]     = new MatrixEffectMove(d0);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void createEffectsPhase1(int duration)
       public void effectFinishedPlugin(final long effectID)
+        {
         Dynamic3D d0 = new Dynamic3D(1,0.5f);
         d0.add(new Static3D(0,0,0));
         mCubeEffectPosition[1]  = new int[] {-1};
         mCubeEffects[1]         = new Effect[mCubeEffectPosition[1].length];
         mCubeEffects[1][0]      = new MatrixEffectMove(d0);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Copyright 2019 Leszek Koltunski                                                               //
     //                                                                                               //
     // This file is part of Distorted.                                                               //
     //                                                                                               //
     // Distorted is free software: you can redistribute it and/or modify                             //
     // it under the terms of the GNU General Public License as published by                          //
     // the Free Software Foundation, either version 2 of the License, or                             //
     // (at your option) any later version.                                                           //
     //                                                                                               //
     // Distorted is distributed in the hope that it will be useful,                                  //
     // but WITHOUT ANY WARRANTY; without even the implied warranty of                                //
     // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //
     // GNU General Public License for more details.                                                  //
     //                                                                                               //
     // You should have received a copy of the GNU General Public License                             //
     // along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     package org.distorted.effect;
     import org.distorted.library.effect.Effect;
     import org.distorted.library.effect.MatrixEffectMove;
     import org.distorted.library.type.Dynamic;
     import org.distorted.library.type.Dynamic3D;
     import org.distorted.library.type.Static3D;
     import static org.distorted.magic.RubikRenderer.TEXTURE_SIZE;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     public class ScrambleEffectRotations extends ScrambleEffect
+      {
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void createEffects(int duration)
+        {
         mCubeEffectNumber[EFFECT_FLAVOUR_PLUGIN]   = 1;
         mNodeEffectNumber[EFFECT_FLAVOUR_PLUGIN]   = 0;
         mCubeEffectPosition[EFFECT_FLAVOUR_PLUGIN] = new int[] {6};
         mCubeEffects[EFFECT_FLAVOUR_PLUGIN]        = new Effect[mCubeEffectPosition[EFFECT_FLAVOUR_PLUGIN].length];
         float Z = TEXTURE_SIZE/3;
         Dynamic3D d0 = new Dynamic3D(duration, 0.5f);
         d0.setMode(Dynamic.MODE_PATH);
         d0.add(new Static3D( 0, 0, 0));
         d0.add(new Static3D( 0, 0,-Z));
         d0.add(new Static3D( 0, 0, 0));
         mCubeEffects[EFFECT_FLAVOUR_PLUGIN][0] = new MatrixEffectMove(d0);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void effectFinishedPlugin(final long effectID)
+        {
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Enable all effects used in this Effect. Called by reflection from the parent class.
       @SuppressWarnings("unused")
       static void enable()
+        {
+        }
+      }

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision a62aa9d7

Added by Leszek Koltunski about 5 years ago