Magic Cube

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

// Copyright 2020 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.tutorials;

import android.content.Context;

import android.content.res.Resources;

import org.distorted.effects.BaseEffect;

import org.distorted.effects.EffectController;

import org.distorted.helpers.BlockController;

import org.distorted.helpers.MovesFinished;

import org.distorted.helpers.TwistyPreRender;

import org.distorted.objects.ObjectList;

import org.distorted.objects.TwistyObject;

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

public class TutorialPreRender implements EffectController, TwistyPreRender

  {

  private MovesFinished mAddActionListener;

  private final TutorialSurfaceView mView;

  private boolean mFinishRotation, mRemoveRotation, mAddRotation,

                  mSetQuat, mChangeObject, mSetupObject, mSolveObject, mScrambleObject,

                  mInitializeObject, mResetAllTextureMaps, mRemovePatternRotation, mSolve;

  private boolean mUIBlocked, mTouchBlocked;

  private boolean mIsSolved;

  private ObjectList mNextObject;

  private int mNextSize;

  private long mRotationFinishedID;

  private int mScreenWidth;

  private TwistyObject mOldObject, mNewObject;

  private int mAddRotationAxis, mAddRotationRowBitmap, mAddRotationAngle;

  private long mAddRotationDuration;

  private long mAddRotationID, mRemoveRotationID;

  private int mNearestAngle;

  private int mScrambleObjectNum;

  private final BlockController mBlockController;

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

  TutorialPreRender(TutorialSurfaceView view)

    {

    mView = view;

    mFinishRotation = false;

    mRemoveRotation = false;

    mAddRotation    = false;

    mSetQuat        = false;

    mChangeObject   = false;

    mSetupObject    = false;

    mSolveObject    = false;

    mSolve          = false;

    mScrambleObject = false;

    mOldObject      = null;

    mNewObject      = null;

    mScreenWidth       = 0;

    mScrambleObjectNum = 0;

    mRemovePatternRotation= false;

    TutorialActivity act = (TutorialActivity)mView.getContext();

    mBlockController = new BlockController(act);

    unblockEverything();

    }

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

  private void createObjectNow(ObjectList object, int size)

    {

    if( mOldObject!=null ) mOldObject.releaseResources();

    mOldObject = mNewObject;

    Context con = mView.getContext();

    Resources res = con.getResources();

    mNewObject = object.create(size, mView.getQuat(), null, res, mScreenWidth);

    if( mNewObject!=null )

      {

      mNewObject.createTexture();

      mView.setMovement(object.getObjectMovementClass());

      if( mScreenWidth!=0 )

        {

        mNewObject.recomputeScaleFactor(mScreenWidth);

        }

      mIsSolved = mNewObject.isSolved();

      }

    }

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

  private void doEffectNow(BaseEffect.Type type)

    {

    try

      {

      type.startEffect(mView.getRenderer().getScreen(),this);

      }

    catch( Exception ex )

      {

      android.util.Log.e("renderer", "exception starting effect: "+ex.getMessage());

      unblockEverything();

      }

    }

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

  private void removePatternRotation()

    {

    mRemovePatternRotation = true;

    }

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

  private void removePatternRotationNow()

    {

    mRemovePatternRotation=false;

    mNewObject.removeRotationNow();

    mAddActionListener.onActionFinished(mRemoveRotationID);

    }

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

  private void removeRotationNow()

    {

    mRemoveRotation=false;

    mNewObject.removeRotationNow();

    boolean solved = mNewObject.isSolved();

    unblockEverything();

    if( solved && !mIsSolved ) doEffectNow( BaseEffect.Type.WIN );

    mIsSolved = solved;

    }

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

  private void removeRotation()

    {

    mRemoveRotation = true;

    }

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

  private void addRotationNow()

    {

    mAddRotation = false;

    mAddRotationID = mNewObject.addNewRotation( mAddRotationAxis, mAddRotationRowBitmap,

                                                mAddRotationAngle, mAddRotationDuration, this);

    if( mAddRotationID==0 ) // failed to add effect - should never happen

      {

      unblockEverything();

      }

    }

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

  private void finishRotationNow()

    {

    mFinishRotation = false;

    blockEverything(BlockController.TUTORIAL_PLACE_0);

    mRotationFinishedID = mNewObject.finishRotationNow(this, mNearestAngle);

    if( mRotationFinishedID==0 ) // failed to add effect - should never happen

      {

      unblockEverything();

      }

    }

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

  private void changeObjectNow()

    {

    mChangeObject = false;

    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getNumLayers()!=mNextSize)

      {

      blockEverything(BlockController.TUTORIAL_PLACE_1);

      createObjectNow(mNextObject, mNextSize);

      doEffectNow( BaseEffect.Type.SIZECHANGE );

      }

    }

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

  private void setupObjectNow()

    {

    mSetupObject = false;

    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getNumLayers()!=mNextSize)

      {

      blockEverything(BlockController.TUTORIAL_PLACE_2);

      createObjectNow(mNextObject, mNextSize);

      doEffectNow( BaseEffect.Type.SIZECHANGE );

      }

    else

      {

      mNewObject.initializeObject(null);

      }

    }

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

  private void scrambleObjectNow()

    {

    mScrambleObject = false;

    mIsSolved       = false;

    blockEverything(BlockController.TUTORIAL_PLACE_3);

    doEffectNow( BaseEffect.Type.SCRAMBLE );

    }

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

  private void solveObjectNow()

    {

    mSolveObject = false;

    blockEverything(BlockController.TUTORIAL_PLACE_4);

    doEffectNow( BaseEffect.Type.SOLVE );

    }

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

  private void solveNow()

    {

    mSolve = false;

    mNewObject.solve();

    }

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

  private void initializeObjectNow()

    {

    mInitializeObject = false;

    mNewObject.initializeObject(null);

    }

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

  private void resetAllTextureMapsNow()

    {

    mResetAllTextureMaps = false;

    if( mNewObject!=null ) mNewObject.resetAllTextureMaps();

    }

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

  private void setQuatNow()

    {

    mSetQuat = false;

    mView.setQuat();

    }

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

//

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

  void setScreenSize(int width)

    {

    if( mNewObject!=null )

      {

      mNewObject.createTexture();

      mNewObject.recomputeScaleFactor(width);

      }

    mScreenWidth  = width;

    }

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

  void finishRotation(int nearestAngle)

    {

    mNearestAngle   = nearestAngle;

    mFinishRotation = true;

    }

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

  void changeObject(ObjectList object, int size)

    {

    if( size>0 )

      {

      mChangeObject = true;

      mNextObject = object;

      mNextSize   = size;

      }

    }

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

  void setQuatOnNextRender()

    {

    mSetQuat = true;

    }

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

  void preRender()

    {

    if( mSolve                 ) solveNow();

    if( mSetQuat               ) setQuatNow();

    if( mFinishRotation        ) finishRotationNow();

    if( mRemoveRotation        ) removeRotationNow();

    if( mChangeObject          ) changeObjectNow();

    if( mSetupObject           ) setupObjectNow();

    if( mSolveObject           ) solveObjectNow();

    if( mScrambleObject        ) scrambleObjectNow();

    if( mAddRotation           ) addRotationNow();

    if( mInitializeObject      ) initializeObjectNow();

    if( mResetAllTextureMaps   ) resetAllTextureMapsNow();

    if( mRemovePatternRotation ) removePatternRotationNow();

    }

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

// PUBLIC API

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

  public boolean isTouchBlocked()

    {

    return mTouchBlocked;

    }

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

  public boolean isUINotBlocked()

    {

    return !mUIBlocked;

    }

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

  public void blockEverything(int place)

    {

    mUIBlocked   = true;

    mTouchBlocked= true;

    mBlockController.touchBlocked(place);

    mBlockController.uiBlocked(place);

    }

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

  public void blockTouch(int place)

    {

    mTouchBlocked= true;

    mBlockController.touchBlocked(place);

    }

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

  public void unblockEverything()

    {

    mUIBlocked   = false;

    mTouchBlocked= false;

    mBlockController.touchUnblocked();

    mBlockController.uiUnblocked();

    }

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

  public void unblockTouch()

    {

    mTouchBlocked= false;

    mBlockController.touchUnblocked();

    }

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

  public void unblockUI()

    {

    mUIBlocked= false;

    mBlockController.uiUnblocked();

    }

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

  public void addRotation(MovesFinished listener, int axis, int rowBitmap, int angle, long duration)

    {

    mAddRotation = true;

    mAddActionListener    = listener;

    mAddRotationAxis      = axis;

    mAddRotationRowBitmap = rowBitmap;

    mAddRotationAngle     = angle;

    mAddRotationDuration  = duration;

    }

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

  public int getNumScrambles()

    {

    return mScrambleObjectNum;

    }

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

// this starts the SolveEffect

  public void solveObject()

    {

    if( !mUIBlocked )

      {

      mSolveObject = true;

      }

    }

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

// this only solves the object

  public void solve()

    {

    mSolve = true;

    }

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

  public void scrambleObject(int num)

    {

    if( !mUIBlocked )

      {

      mScrambleObject = true;

      mScrambleObjectNum = num;

      }

    }

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

  public void resetAllTextureMaps()

    {

    mResetAllTextureMaps = true;

    }

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

  public TwistyObject getObject()

    {

    return mNewObject;

    }

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

  public TwistyObject getOldObject()

    {

    return null;

    }

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

  public void effectFinished(final long effectID)

    {

    if( effectID == mRotationFinishedID )

      {

      mRotationFinishedID = 0;

      removeRotation();

      }

    else if( effectID == mAddRotationID )

      {

      mAddRotationID = 0;

      mRemoveRotationID = effectID;

      removePatternRotation();

      }

    else

      {

      unblockEverything();  // buggy? I think we shouldn't do it if the effect is of type 'WIN'

      }

    }

  }