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

import android.content.SharedPreferences;

import org.distorted.library.main.QuatHelper;

import org.distorted.library.type.Static4D;

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

public class TwistyObjectCubit

  {

  public static final int TYPE_NORMAL   = 0;  // all 'old', 'pre-crazy' cubits

  public static final int TYPE_FOLLOWER = 1;  // those cubits that follow deciders (e.g. small circle edges from Crazy Plus planets)

  public static final int TYPE_DECIDER  = 2;  // cubits deciding about rotation rows of their followers (e.g. center cubits of Crazy Plus Planets)

  private final float[] mTmp;

  private final float[] mOrigPosition;

  private final float[] mCurrentPosition;

  private final float[] mRowOffset;

  private final float mOrigOffsetX, mOrigOffsetY, mOrigOffsetZ;

  private final int mNumAxis;

  private final int mLen;

  private final int[] mRotationRow;

  private final int mCubitType;

  private final int mOrigPuzzleFace;

  private final int mCubitIndex;

  private final int mMaxLayers;

  private float[] mTrackingPoint;

  private int mCurrentPuzzleFace;

  private TwistyObject mParent;

  int mQuatIndex;

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

  TwistyObjectCubit(TwistyObject parent, float[] position, int numAxis, int maxLayers, int cubitIndex)

    {

    mQuatIndex= 0;

    mParent   = parent;

    mLen      = position.length;

    mMaxLayers= maxLayers;

    mCubitType    = mParent.getCubitRotationType(cubitIndex);

    mRowOffset    = mParent.getCubitRowOffset(cubitIndex);

    mTrackingPoint= mParent.getTrackingPoint(cubitIndex,mCubitType);

    int face      = mParent.computeCurrentPuzzleFace(mCubitType,mTrackingPoint);

    if( mRowOffset!=null )

      {

      mOrigOffsetX = mRowOffset[0];

      mOrigOffsetY = mRowOffset[1];

      mOrigOffsetZ = mRowOffset[2];

      if( mCubitType==TYPE_DECIDER ) mParent.setRotationRowOffset(face,mRowOffset);

      }

    else

      {

      mOrigOffsetX = 0;

      mOrigOffsetY = 0;

      mOrigOffsetZ = 0;

      }

    mCubitIndex       = cubitIndex;

    mOrigPuzzleFace   = face;

    mCurrentPuzzleFace= face;

    mOrigPosition     = new float[mLen];

    mCurrentPosition  = new float[mLen];

    mTmp              = new float[4];

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

      {

      mOrigPosition[i]    = position[i];

      mCurrentPosition[i] = position[i];

      }

    mNumAxis     = numAxis;

    mRotationRow = new int[mNumAxis];

    computeRotationRow();

    }

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

// Because of quatMultiplication, errors can accumulate - so to avoid this, we

// correct the value of the 'scramble' quat to what it should be - one of the legal quats from the

// list QUATS.

//

// We also have to remember that the group of unit quaternions is a double-cover of rotations

// in 3D ( q represents the same rotation as -q ) - so invert if needed.

  private int normalizeScrambleQuat(Static4D quat)

    {

    float x = quat.get0();

    float y = quat.get1();

    float z = quat.get2();

    float w = quat.get3();

    float xd,yd,zd,wd;

    float diff, mindiff = Float.MAX_VALUE;

    int ret=0;

    int num_quats = mParent.mObjectQuats.length;

    Static4D qt;

    for(int q=0; q<num_quats; q++)

      {

      qt = mParent.mObjectQuats[q];

      xd = x - qt.get0();

      yd = y - qt.get1();

      zd = z - qt.get2();

      wd = w - qt.get3();

      diff = xd*xd + yd*yd + zd*zd + wd*wd;

      if( diff < mindiff )

        {

        ret = q;

        mindiff = diff;

        }

      xd = x + qt.get0();

      yd = y + qt.get1();

      zd = z + qt.get2();

      wd = w + qt.get3();

      diff = xd*xd + yd*yd + zd*zd + wd*wd;

      if( diff < mindiff )

        {

        ret = q;

        mindiff = diff;

        }

      }

    return ret;

    }

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

  void computeRotationRow()

    {

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

      {

      mRotationRow[i] = mParent.computeRow(mCurrentPosition,i,mCubitType,mCurrentPuzzleFace);

      }

    }

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

  int computeAssociation()

    {

    int result = 0, accumulativeShift = 0;

    for(int axis=0; axis<mNumAxis; axis++)

      {

      result += (mRotationRow[axis]<<accumulativeShift);

      accumulativeShift += mMaxLayers;

      }

    return result;

    }

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

  private String createKey(String key)

    {

    return key+"_"+mCubitIndex+"_"+mOrigPosition[0]+"_"+mOrigPosition[1]+"_"+mOrigPosition[2];

    }

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

  void savePreferences(String key, SharedPreferences.Editor editor)

    {

    editor.putInt(createKey(key), mQuatIndex);

    }

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

  void removePreferences(String key, SharedPreferences.Editor editor)

    {

    editor.remove(createKey(key));

    }

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

  int restorePreferences(String key, SharedPreferences preferences)

    {

    mQuatIndex = preferences.getInt(createKey(key), 0);

    return mQuatIndex;

    }

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

// only for debugging

  float[] getTrackingPoint()

    {

    return mTrackingPoint;

    }

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

  boolean rotateCubit(Static4D quat)

    {

    boolean result = true;

    int len = mLen/3;

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

      {

      QuatHelper.rotateVectorByQuat( mTmp, mCurrentPosition[3*i], mCurrentPosition[3*i+1], mCurrentPosition[3*i+2], 0, quat);

      mCurrentPosition[3*i  ] = mTmp[0];

      mCurrentPosition[3*i+1] = mTmp[1];

      mCurrentPosition[3*i+2] = mTmp[2];

      mParent.clampPos(mCurrentPosition, 3*i);

      }

    if( mCubitType!=TYPE_NORMAL )

      {

      QuatHelper.rotateVectorByQuat( mTmp, mTrackingPoint[0], mTrackingPoint[1], mTrackingPoint[2], 0, quat);

      mTrackingPoint[0] = mTmp[0];

      mTrackingPoint[1] = mTmp[1];

      mTrackingPoint[2] = mTmp[2];

      mCurrentPuzzleFace = mParent.computeCurrentPuzzleFace(mCubitType,mTrackingPoint);

      if( mCurrentPuzzleFace<0 )  // unexpected error

        {

        mCurrentPuzzleFace = 0;

        result = false;

        }

      }

    if( mCubitType==TYPE_DECIDER )

      {

      QuatHelper.rotateVectorByQuat( mTmp, mRowOffset[0], mRowOffset[1], mRowOffset[2], 0, quat);

      mRowOffset[0] = mTmp[0];

      mRowOffset[1] = mTmp[1];

      mRowOffset[2] = mTmp[2];

      }

    return result;

    }

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

  int postRotateCubit(Static4D quat)

    {

    Static4D q = QuatHelper.quatMultiply(quat,mParent.mObjectQuats[mQuatIndex]);

    mQuatIndex = normalizeScrambleQuat(q);

    computeRotationRow();

    return mQuatIndex;

    }

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

  void solve()

    {

    mQuatIndex = 0;

    mCurrentPuzzleFace = mOrigPuzzleFace;

    System.arraycopy(mOrigPosition, 0, mCurrentPosition, 0, mCurrentPosition.length);

    if( mCubitType!=TYPE_NORMAL )

      {

      mTrackingPoint = mParent.getTrackingPoint(mCubitIndex,mCubitType);

      if( mCubitType==TYPE_DECIDER )

        {

        mRowOffset[0] = mOrigOffsetX;

        mRowOffset[1] = mOrigOffsetY;

        mRowOffset[2] = mOrigOffsetZ;

        }

      }

    }

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

  void releaseResources()

    {

    mParent = null;

    }

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

  public int getType()

    {

    return mCubitType;

    }

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

  public float[] getOffset()

    {

    return mRowOffset;

    }

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

  public int getPuzzleFace()

    {

    return mCurrentPuzzleFace;

    }

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

  public int getRotRow(int axisIndex)

    {

    return mRotationRow[axisIndex];

    }

}