Magic Cube

///////////////////////////////////////////////////////////////////////////////////////////////////

// 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/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.message.EffectListener;

import org.distorted.magic.RubikCube;

import java.lang.reflect.Method;

///////////////////////////////////////////////////////////////////////////////////////////////////

  public enum Type

    {

    NONE         (ScrambleEffectNone.class        ),

    final Class<? extends ScrambleEffect> effect;

    Type(Class<? extends ScrambleEffect> effect)

      {

      this.effect= effect;

      }

    }

  private static 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 EffectListener mListener;

  private long mCurrentBaseEffectID;

  private int mNumDoubleScramblesLeft, mNumScramblesLeft;

  private int mLastVector;

  private long mDurationSingleTurn;

  private Random mRnd;

  int[] mNodeEffectPosition;

  Effect[] mCubeEffects;

  int[] mCubeEffectPosition;

  int mCubeEffectNumber, mNodeEffectNumber;

///////////////////////////////////////////////////////////////////////////////////////////////////

  ScrambleEffect()

    {

    mLastVector = -1;

///////////////////////////////////////////////////////////////////////////////////////////////////

  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;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////

  abstract void effectFinishedPlugin(final long effectID);

///////////////////////////////////////////////////////////////////////////////////////////////////

    // compute how many out of 'numScrambles' are double turns.

    mNumDoubleScramblesLeft=0;

    for(int i=0; i<numScrambles; i++)

      {

      if( (mRnd.nextInt() % 3) == 0 )

        {

        mNumDoubleScramblesLeft++;

        }

      }

    mDurationSingleTurn = duration/(mNumScramblesLeft+mNumDoubleScramblesLeft);

    addNewScramble();

      {

      if( mLastVector == -1 )

        {

        switch(mRnd.nextInt(3))

          {

          case 0: mLastVector = RubikCube.VECTX; break;

          case 1: mLastVector = RubikCube.VECTY; break;

          case 2: mLastVector = RubikCube.VECTZ; break;

          }

        }

      else

        {

        int newVector = mRnd.nextInt(2);

        switch(mLastVector)

          {

          case RubikCube.VECTX: mLastVector = (newVector==0 ? RubikCube.VECTY: RubikCube.VECTZ); break;

          case RubikCube.VECTY: mLastVector = (newVector==0 ? RubikCube.VECTX: RubikCube.VECTZ); break;

          case RubikCube.VECTZ: mLastVector = (newVector==0 ? RubikCube.VECTX: RubikCube.VECTY); break;

          }

        }

      int row  = mRnd.nextInt(mCube.getSize());

      int angle= randomizeAngle();

      int absAngle = (angle<0 ? -angle : angle);

      long durationMillis =  absAngle*mDurationSingleTurn;

      mNumScramblesLeft--;

      if( absAngle==2 ) mNumDoubleScramblesLeft--;

        {

        android.util.Log.e("effect", "ERROR: "+mNumDoubleScramblesLeft);

        }

      }

    else

      {

      mLastVector = -1;

      if( mEffectReturned == mCubeEffectNumber+mNodeEffectNumber )

        {

        mListener.effectFinished(FAKE_EFFECT_ID);

        }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int randomizeAngle()

    {

    int result = random<mNumDoubleScramblesLeft ? 2:1;

    int sign   = mRnd.nextInt(2);

    return sign==0 ? result : -result;

///////////////////////////////////////////////////////////////////////////////////////////////////

      {

      mCube.removeRotationNow();

      addNewScramble();

      return;

      }

    for(int i=0; i<mCubeEffectNumber; i++)

      if( effectID == id )

        effectFinishedPlugin(effectID);

          if( mNumScramblesLeft==0 )

            {

            mListener.effectFinished(FAKE_EFFECT_ID);

            }

        }

      }

      {

      long id = mNodeEffects[i].getID();

        effectFinishedPlugin(effectID);

          if( mNumScramblesLeft==0 )

            {

            mListener.effectFinished(FAKE_EFFECT_ID);

            }

        return;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

    mListener = renderer;

    createBaseEffects(numScrambles*duration, numScrambles);

    createEffects(numScrambles*duration);

      throw new RuntimeException("Cube and Node Plugin Effects not created!");

      }

    return FAKE_EFFECT_ID;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

      mCubeEffects[i].notifyWhenFinished(this);

    DistortedEffects nodeEffects = mCube.getEffects();

      mNodeEffects[i].notifyWhenFinished(this);

///////////////////////////////////////////////////////////////////////////////////////////////////

    DistortedEffects nodeEffects = mCube.getEffects();

///////////////////////////////////////////////////////////////////////////////////////////////////

  @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());

        }

      }

    }

}