TwistyPuzzleLib

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

// Copyright 2019 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.objectchange;

import java.lang.reflect.Method;

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.main.TwistyObjectNode;

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

public abstract class ObjectChangeEffect extends BaseEffect implements EffectListener

{

  public enum Type

    {

    NONE         (ObjectChangeEffectNone.class        ),

    TRANSPARENCY (ObjectChangeEffectTransparency.class),

    MOVE         (ObjectChangeEffectMove.class        ),

    ROUND        (ObjectChangeEffectRound.class       ),

    SCALE        (ObjectChangeEffectScale.class       ),

    ;

    final Class<? extends ObjectChangeEffect> effect;

    Type(Class<? extends ObjectChangeEffect> effect)

      {

      this.effect= effect;

      }

    }

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

  private static final int NUM_PHASES  = 2;

  private static final int FAKE_EFFECT_ID  = -1;

  private static final Type[] types;

  static

    {

    int i=0;

    types = new Type[NUM_EFFECTS];

    for(Type type: Type.values())

      {

      types[i++] = type;

      }

    }

  private int mDuration;

  private final int[] mEffectReturned;

  private final int[] mCubeEffectNumber, mNodeEffectNumber;

  private final int[] mEffectFinished;

  private final boolean[] mPhaseActive;

  ObjectPreRender mPre;

  TwistyObject[] mObject;

  TwistyObjectNode mObjectNode;

  Effect[][] mCubeEffects;

  int[][] mCubeEffectPosition;

  Effect[][] mNodeEffects;

  int[][] mNodeEffectPosition;

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

  ObjectChangeEffect()

    {

    mPhaseActive        = new boolean[NUM_PHASES];

    mEffectReturned     = new int[NUM_PHASES];

    mCubeEffectNumber   = new int[NUM_PHASES];

    mNodeEffectNumber   = new int[NUM_PHASES];

    mEffectFinished     = new int[NUM_PHASES];

    mCubeEffectPosition = new int[NUM_PHASES][];

    mNodeEffectPosition = new int[NUM_PHASES][];

    mCubeEffects        = new Effect[NUM_PHASES][];

    mNodeEffects        = new Effect[NUM_PHASES][];

    mObject             = new TwistyObject[NUM_PHASES];

    }

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

  abstract int createEffectsPhase0(int duration);

  abstract int createEffectsPhase1(int duration);

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

  private void effectFinishedPhase(final long effectID, int phase)

    {

    for(int i=0; i<mCubeEffectNumber[phase]; i++)

      {

      long id = mCubeEffects[phase][i].getID();

      if( effectID == id )

        {

        effectReturned(phase);

        mObject[phase].removeEffect(id);

        return;

        }

      }

    for(int i=0; i<mNodeEffectNumber[phase]; i++)

      {

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

      if( effectID == id )

        {

        effectReturned(phase);

        mObjectNode.getEffects().abortById(id);

        return;

        }

      }

    }

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

  private void phase0finished()

    {

    mPhaseActive[1] = true;

    mEffectFinished[1] = createEffectsPhase1(mDuration);

    assignEffects(1);

    if( mPre!=null )

      {

      int numFaces = mObject[1].getNumPuzzleFaces();

      mPre.setDefaultRotation(numFaces);

      }

    mObjectNode.attach(mObject[1].getNode());

    mObjectNode.setFOV(mObject[1].getFOV());

    }

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

  private void effectReturned(int phase)

    {

    mEffectReturned[phase]++;

    if( mEffectReturned[phase] == mEffectFinished[phase] )

      {

      switch(phase)

        {

        case 0: phase0finished();

                break;

        case 1: mPre.effectFinished(FAKE_EFFECT_ID);

                break;

        }

      }

    if( mEffectReturned[phase] == mCubeEffectNumber[phase]+mNodeEffectNumber[phase] )

      {

      switch(phase)

        {

        case 0: mPhaseActive[0] = false;

                mObjectNode.detach(mObject[0].getNode());

                break;

        case 1: mPhaseActive[1] = false;

                break;

        }

      }

    }

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

  private void assignEffects(int phase)

    {

    mCubeEffectNumber[phase] = ( mCubeEffects[phase]!=null ) ? mCubeEffects[phase].length : 0;

    mNodeEffectNumber[phase] = ( mNodeEffects[phase]!=null ) ? mNodeEffects[phase].length : 0;

    if( mCubeEffectNumber[phase]==0 && mNodeEffectNumber[phase]==0 )

      {

      throw new RuntimeException("Cube and Node Effects ("+phase+" phase) both not created!");

      }

    for(int i=0; i<mCubeEffectNumber[phase]; i++)

      {

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

      mCubeEffects[phase][i].notifyWhenFinished(this);

      }

    DistortedEffects nodeEffects = mObjectNode.getEffects();

    for(int i=0; i<mNodeEffectNumber[phase]; i++)

      {

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

      mNodeEffects[phase][i].notifyWhenFinished(this);

      }

    }

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

// PUBLIC API

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

  public void effectFinished(final long effectID)

    {

    if( mPhaseActive[0] ) effectFinishedPhase(effectID,0);

    if( mPhaseActive[1] ) effectFinishedPhase(effectID,1);

    }

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

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

    {

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

    }

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

  @SuppressWarnings("unused")

  public long start(int duration, ObjectPreRender pre)

    {

    mObject[0] = pre.getOldObject();

    mObject[1] = pre.getObject();

    mObjectNode= pre.getObjectNode();

    mPre       = pre;

    mDuration  = duration;

    if( mObject[0]!=null )

      {

      mPhaseActive[0] = true;

      mEffectFinished[0] = createEffectsPhase0(mDuration);

      assignEffects(0);

      }

    else phase0finished();

    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("SizeChangeEffect", type.effect.getSimpleName()+": exception getting method: "+ex.getMessage());

        method = null;

        }

      try

        {

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

        }

      catch(Exception ex)

        {

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

        }

      }

    }

}