TwistyPuzzleLib

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

// Copyright 2022 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

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

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

package org.distorted.objectlib.effects.present;

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;

import org.distorted.objectlib.main.ObjectPreRender;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.effects.BaseEffect;

import org.distorted.objectlib.helpers.MovesFinished;

import org.distorted.objectlib.main.TwistyObjectNode;

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

public abstract class PresentEffect extends BaseEffect implements EffectListener, MovesFinished

{

  public enum Type

    {

    SPIN (PresentEffectSpin.class),

    ;

    final Class<? extends PresentEffect> effect;

    Type(Class<? extends PresentEffect> effect)

      {

      this.effect= effect;

      }

    }

  private static final int NUM_EFFECTS = PresentEffect.Type.values().length;

  private static final int FAKE_EFFECT_ID  = -6;

  private static final int EXTRA_DURATION = 3000;

  private static final PresentEffect.Type[] types;

  static

    {

    int i=0;

    types = new PresentEffect.Type[NUM_EFFECTS];

    for(PresentEffect.Type type: PresentEffect.Type.values())

      {

      types[i++] = type;

      }

    }

  private int mDurationPerDegree;

  private final Random mRnd;

  private int[][] mBasicAngle;

  private boolean mScrambleForward;

  private int mTotalDuration;

  ObjectPreRender mPre;

  TwistyObject mObject;

  TwistyObjectNode mObjectNode;

  Effect[] mNodeEffects;

  int[] mNodeEffectPosition;

  Effect[] mCubeEffects;

  int[] mCubeEffectPosition;

  int mCubeEffectNumber, mNodeEffectNumber;

  int mNumScrambles, mCurrScramble;

  int[][] mScrambles;

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

  PresentEffect()

    {

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

    }

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

  abstract void createEffects(int duration, int numScrambles);

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

  private void createBaseEffects(int numScrambles)

    {

    mNumScrambles = numScrambles;

    mCurrScramble = 0;

    mScrambleForward = true;

    randomizeScrambles();

    addNewScramble();

    }

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

  private int computeRowFromBitmap(int rowBitmap)

    {

    int index = 0;

    while(index<32)

      {

      if( (rowBitmap&0x1) != 0 ) return index;

      rowBitmap>>=1;

      index++;

      }

    return 0;

    }

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

  private void randomizeScrambles()

    {

    int absAngle, angle, axis, row, basicDegrees, totalDegrees = 0;

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

      {

      mObject.randomizeNewScramble(mScrambles, mRnd, scramble, mNumScrambles);

      int[] s = mScrambles[scramble];

      axis  = s[0];

      row   = computeRowFromBitmap(s[1]);

      angle = s[2];

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

      basicDegrees = 360/mBasicAngle[axis][row];

      totalDegrees += absAngle*basicDegrees;

      }

    mDurationPerDegree = mTotalDuration/(2*totalDegrees);

    }

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

  private void addNewScramble()

    {

    if( mScrambleForward )

      {

      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( mCurrScramble>=mNumScrambles )

        {

        Thread thread = new Thread()

          {

          public void run()

            {

            try { sleep(EXTRA_DURATION); }

            catch(InterruptedException ex) { }

            addRotation(false);

            }

          };

        thread.start();

        }

      else

        {

        addRotation(false);

        }

      }

    }

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

  private void addRotation(boolean forward)

    {

    if( !forward ) mCurrScramble--;

    int axis = mScrambles[mCurrScramble][0];

    int row  = mScrambles[mCurrScramble][1];

    int angle= mScrambles[mCurrScramble][2];

    if( !forward ) angle = -angle;

    mPre.addRotation(this, axis, row, angle, mDurationPerDegree);

    if( forward ) mCurrScramble++;

    if( mCurrScramble>=mNumScrambles ) mScrambleForward=false;

    if( mCurrScramble<=0             ) mScrambleForward=true;

    }

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

  private void assignEffects()

    {

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

      {

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

      mCubeEffects[i].notifyWhenFinished(this);

      }

    DistortedEffects nodeEffects = mObjectNode.getEffects();

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

      {

      nodeEffects.apply(mNodeEffects[i],mNodeEffectPosition[i]);

      mNodeEffects[i].notifyWhenFinished(this);

      }

    }

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

// 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 PresentEffect create(int ordinal) throws InstantiationException, IllegalAccessException

    {

    return types[ordinal].effect.newInstance();

    }

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

  public void onActionFinished(final long effectID)

    {

    addNewScramble();

    }

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

  public void effectFinished(final long effectID)

    {

    }

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

  @SuppressWarnings("unused")

  public long start(int duration, ObjectPreRender pre)

    {

    mObject     = pre.getObject();

    mObjectNode = pre.getObjectNode();

    mPre        = pre;

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

    mBasicAngle = mObject.getBasicAngles();

    int numScrambles = pre.getNumScrambles();

    mScrambles = new int[numScrambles][3];

    mTotalDuration = (int)(duration*Math.pow(numScrambles,0.66f));

    createBaseEffects(numScrambles);

    createEffects(mTotalDuration,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(PresentEffect.Type type: PresentEffect.Type.values())

      {

      try

        {

        method = type.effect.getDeclaredMethod("enable"); // enable not public, thus getDeclaredMethod

        }

      catch(NoSuchMethodException ex)

        {

        android.util.Log.e("PresentEffect", type.effect.getSimpleName()+": exception getting method: "+ex.getMessage());

        method = null;

        }

      try

        {

        if( method!=null ) method.invoke(null);

        }

      catch(Exception ex)

        {

        android.util.Log.e("PresentEffect", type.effect.getSimpleName()+": exception invoking method: "+ex.getMessage());

        }

      }

    }

}