Magic Cube

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

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

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.effects.scramble;

import org.distorted.effects.BaseEffect;

import org.distorted.library.effect.Effect;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.message.EffectListener;

import org.distorted.main.RubikPreRender;

import org.distorted.effects.EffectController;

import org.distorted.objects.ObjectList;

import org.distorted.objects.TwistyObject;

import java.lang.reflect.Method;

import java.util.Random;

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

public abstract class ScrambleEffect extends BaseEffect implements EffectListener, RubikPreRender.ActionFinishedListener

{

  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 EffectController mController;

  private int mEffectReturned;

  private int mNumDoubleScramblesLeft, mNumScramblesLeft;

  private long mDurationSingleTurn;

  private final Random mRnd;

  private int mBasicAngle;

  private boolean mRotReady, mPluginReady;

  TwistyObject mObject;

  Effect[] mNodeEffects;

  int[] mNodeEffectPosition;

  Effect[] mCubeEffects;

  int[] mCubeEffectPosition;

  int mCubeEffectNumber, mNodeEffectNumber;

  int mNumScrambles;

  int[][] mScrambles;

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

  ScrambleEffect()

    {

    mRnd = new Random( System.currentTimeMillis() );

    mScrambles = new int[ObjectList.MAX_LEVEL][3];

    }

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

  abstract void createEffects(int duration, int numScrambles);

  abstract void effectFinishedPlugin(final long effectID);

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

// first compute how many out of 'numScrambles' are double turns (this will matter when we compute

// the time a single quarter-turn takes!

//

// Only works for

// basicAngle==5, i.e. something whose rotations are by  72 degrees (Megaminx) or

// basicAngle==4, i.e. something whose rotations are by  90 degrees (RubikCube) or

// basicAngle==3, i.e. something whose rotations are by 120 degrees (Pyramix) or

// basicAngle==2, i.e. something whose rotations are by 180 degrees (e.g. a 3x2x1 'Bunny')

  private void createBaseEffects(int duration, int numScrambles)

    {

    mNumScramblesLeft = numScrambles;

    mNumDoubleScramblesLeft=0;

    for(int scramble=0; scramble<mNumScramblesLeft; scramble++)

      {

      mObject.randomizeNewScramble(mScrambles, mRnd, scramble);

      int angle = mScrambles[scramble][2];

      if( angle==2 || angle==-2 ) mNumDoubleScramblesLeft++;

      }

    mDurationSingleTurn = duration/(mNumScramblesLeft+mNumDoubleScramblesLeft);

    mNumScrambles = 0;

    mRotReady    = false;

    mPluginReady = false;

    addNewScramble();

    }

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

// only works if basicAngle<=5

  private void addNewScramble()

    {

    if( mNumScramblesLeft>0 )

      {

      int axis = mScrambles[mNumScrambles][0];

      int row  = mScrambles[mNumScrambles][1];

      int angle= mScrambles[mNumScrambles][2];

      int rowBitmap  = (1<<row);

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

      long durationMillis = absAngle*mDurationSingleTurn;

      mNumScramblesLeft--;

      if( absAngle==2 ) mNumDoubleScramblesLeft--;

      if( mNumScramblesLeft==0 && mNumDoubleScramblesLeft!=0 )

        {

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

        }

      mController.addRotation(this, axis, rowBitmap, angle*(360/mBasicAngle), durationMillis);

      mNumScrambles++;

      }

    else

      {

      if( mEffectReturned == mCubeEffectNumber+mNodeEffectNumber )

        {

        mRotReady = true;

        if( mPluginReady ) mController.effectFinished(FAKE_EFFECT_ID);

        }

      }

    }

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

  private void assignEffects()

    {

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

      {

      mObject.apply(mCubeEffects[i],mCubeEffectPosition[i]);

      mCubeEffects[i].notifyWhenFinished(this);

      }

    DistortedEffects nodeEffects = mObject.getEffects();

    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++)

      {

      mObject.remove(mCubeEffects[i].getID());

      }

    DistortedEffects nodeEffects = mObject.getEffects();

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

    }

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

  private void effectFinishedAction(final long effectID, final long id)

    {

    mEffectReturned++;

    effectFinishedPlugin(effectID);

    if( mEffectReturned == mCubeEffectNumber+mNodeEffectNumber )

      {

      disassignEffects();

      if( mNumScramblesLeft==0 )

        {

        mPluginReady = true;

        if( mRotReady ) mController.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,id);

        return;

        }

      }

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

      {

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

      if( effectID == id )

        {

        effectFinishedAction(effectID,id);

        return;

        }

      }

    }

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

  @SuppressWarnings("unused")

  public long start(int duration, DistortedScreen screen, EffectController cont)

    {

    mObject    = cont.getObject();

    mController= cont;

    mObject.solve();

    mBasicAngle = mObject.getBasicAngle();

    int numScrambles = cont.getNumScrambles();

    int dura = (int)(duration*Math.pow(numScrambles,0.6f));

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

        }

      }

    }

}