Magic Cube

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

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

import android.content.SharedPreferences;

import org.distorted.helpers.QuatHelper;

import org.distorted.library.type.Static4D;

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

class Cubit

  {

  private final float[] mOrigPosition;

  private final float[] mCurrentPosition;

  private TwistyObject mParent;

  private final int mNumAxis;

  private final int mLen;

  int mQuatIndex;

  int[] mRotationRow;

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

  Cubit(TwistyObject parent, float[] position, int numAxis)

    {

    mQuatIndex= 0;

    mParent   = parent;

    mLen      = position.length;

    mOrigPosition    = new float[mLen];

    mCurrentPosition = new float[mLen];

    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.OBJECT_QUATS.length;

    Static4D qt;

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

      {

      qt = mParent.OBJECT_QUATS[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;

    }

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

  private void computeRotationRow()

    {

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

      {

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

      }

    }

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

  float[] getOrigPosition()

    {

    return mOrigPosition;

    }

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

  void modifyCurrentPosition(Static4D quat)

    {

    Static4D cubitCenter;

    Static4D rotatedCenter;

    int len = mLen/3;

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

      {

      cubitCenter =  new Static4D(mCurrentPosition[3*i], mCurrentPosition[3*i+1], mCurrentPosition[3*i+2], 0);

      rotatedCenter = QuatHelper.rotateVectorByQuat( cubitCenter, quat);

      mCurrentPosition[3*i  ] = rotatedCenter.get0();

      mCurrentPosition[3*i+1] = rotatedCenter.get1();

      mCurrentPosition[3*i+2] = rotatedCenter.get2();

      mParent.clampPos(mCurrentPosition, 3*i);

      }

    computeRotationRow();

    }

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

  int computeAssociation()

    {

    int result = 0, accumulativeShift = 0;

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

      {

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

      accumulativeShift += ObjectList.MAX_OBJECT_SIZE;

      }

    return result;

    }

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

  void savePreferences(SharedPreferences.Editor editor)

    {

    String number = mOrigPosition[0]+"_"+mOrigPosition[1]+"_"+mOrigPosition[2];

    editor.putInt("q_"+number, mQuatIndex);

    }

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

  int restorePreferences(SharedPreferences preferences)

    {

    String number = mOrigPosition[0]+"_"+mOrigPosition[1]+"_"+mOrigPosition[2];

    mQuatIndex = preferences.getInt("q_"+number, 0);

    return mQuatIndex;

    }

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

  int removeRotationNow(Static4D quat)

    {

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

    mQuatIndex = normalizeScrambleQuat(q);

    modifyCurrentPosition(quat);

    return mQuatIndex;

    }

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

  void solve()

    {

    mQuatIndex = 0;

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

    computeRotationRow();

    }

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

  void releaseResources()

    {

    mParent = null;

    }

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

// this is only needed for MODE_REPLACE objects (i.e. - currently - CUBE_3), so it is enough to only

// take into consideration the first position.

  float getDistSquared(float[] point)

    {

    float dx = mCurrentPosition[0] - point[0];

    float dy = mCurrentPosition[1] - point[1];

    float dz = mCurrentPosition[2] - point[2];

    return dx*dx + dy*dy + dz*dz;

    }

}