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

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

package org.distorted.effect;

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.magic.RubikCube;

import java.lang.reflect.Method;

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

public abstract class DisappearEffect implements EffectListener

  {

  public enum Type

    {

    NONE          (DisappearEffectNone.class       ),

    TRANSPARENCY  (DisappearEffectTransparency.class),

    MOVE          (DisappearEffectMove.class        ),

    ROUND         (DisappearEffectRound.class       ),

    SCALE         (DisappearEffectScale.class       ),

    ;

    private final Class<? extends DisappearEffect> effectClass;

    Type(Class<? extends DisappearEffect> effectClass)

      {

      this.effectClass = effectClass;

      }

    }

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

  private static final Type[] types;

  static

    {

    int i=0;

    types = new Type[NUM_EFFECTS];

    for(Type type: Type.values())

      {

      types[i] = type;

      i++;

      }

    }

  private final int FAKE_EFFECT_ID = -2;

  private EffectListener mListener;

  private RubikCube mCube;

  private int mCubeEffectNumber, mNodeEffectNumber, mEffectFinished, mEffectReturned;

  DistortedScreen mScreen;

  Effect[] mCubeEffects;

  int[] mCubeEffectPosition;

  Effect[] mNodeEffects;

  int[] mNodeEffectPosition;

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

  DisappearEffect()

    {

    mEffectReturned = 0;

    }

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

  abstract int createEffects(int duration);

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

  public static Type getType(int ordinal)

    {

    return types[ordinal];

    }

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

  public void effectFinished(final long effectID)

    {

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

      {

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

      if( effectID == id )

        {

        effectReturned();

        mCube.remove(id);

        break;

        }

      }

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

      {

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

      if( effectID == id )

        {

        effectReturned();

        mCube.getEffects().abortById(id);

        break;

        }

      }

    }

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

  private void effectReturned()

    {

    mEffectReturned++;

    if( mEffectReturned == mEffectFinished )

      {

      mListener.effectFinished(FAKE_EFFECT_ID);

      }

    if( mEffectReturned == mCubeEffectNumber+mNodeEffectNumber )

      {

      mScreen.detach(mCube);

      }

    }

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

  public long start(int duration, DistortedScreen screen, RubikCube cube, EffectListener listener)

    {

    mScreen   = screen;

    mCube     = cube;

    mListener = listener;

    mEffectFinished = createEffects(duration);

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

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

    if( mCubeEffectNumber==0 && mNodeEffectNumber==0 )

      {

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

      }

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

      {

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

      mCubeEffects[i].notifyWhenFinished(this);

      }

    DistortedEffects nodeEffects = mCube.getEffects();

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

      {

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

      mNodeEffects[i].notifyWhenFinished(this);

      }

    return FAKE_EFFECT_ID;

    }

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

  public static DisappearEffect create(Type type) throws InstantiationException, IllegalAccessException

    {

    return type.effectClass.newInstance();

    }

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

  public static void enableEffects()

    {

    Method method=null;

    for(Type type: Type.values())

      {

      Class<? extends DisappearEffect> cls = type.effectClass;

      try

        {

        method = cls.getMethod("enable");

        }

      catch(NoSuchMethodException ex)

        {

        android.util.Log.e("transitionEffect", "exception getting method: "+ex.getMessage());

        }

      try

        {

        method.invoke(null);

        }

      catch(Exception ex)

        {

        android.util.Log.e("transitionEffect", "exception invoking method: "+ex.getMessage());

        }

      }

    }

  }