TwistyPuzzleLib

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

// Copyright 2023 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.tablebases;

import org.distorted.library.main.QuatHelper;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.QuatGroupGenerator;

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

public abstract class TablebasesCreator

{

  private Tablebase mTablebase;

  private final Static3D[] mAxis;

  private final int mSize;

  private final int[][] mAngles;

  private final int mNumAxis;

  private final int[] mNumLayers;

  private final int mNumQuats;

  private final Static4D[] mQuats;

  private final int[][] mRotRow;

  private final int mNumCubits;

  private final float[][] mPosition;

  private final float[][] mCuts;

  private final int[] mNumCuts;

  private int[][] mQuatMult;

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

  abstract int getSize();

  abstract int[][] getBasicAngles();

  abstract Static3D[] getRotationAxis();

  abstract int[] getQuats(int index);

  abstract int getIndex(int[] quats);

  abstract float[][] getPosition();

  abstract float[][] getCuts();

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

  public TablebasesCreator()

    {

    mSize = getSize();

    mAngles = getBasicAngles();

    mAxis = getRotationAxis();

    mNumAxis = mAxis.length;

    mNumLayers = new int[mNumAxis];

    for(int i=0; i<mNumAxis; i++) mNumLayers[i] = mAngles[i].length;

    mQuats = QuatGroupGenerator.computeGroup(mAxis,mAngles);

    mNumQuats = mQuats.length;

    mPosition = getPosition();

    mNumCubits = mPosition.length;

    mCuts = getCuts();

    mNumCuts = new int[mNumAxis];

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

      {

      mNumCuts[i] = (mCuts==null || mCuts[i]==null ? 0 : mCuts[i].length);

      }

    mRotRow = new int[mNumCubits][mNumAxis];

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

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

        {

        mRotRow[i][j] = computeRow(mPosition[i],j);

        }

    }

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

  private int computeRow(float[] pos, int axisIndex)

    {

    int ret=0;

    int len = pos.length/3;

    Static3D axis = mAxis[axisIndex];

    float axisX = axis.get0();

    float axisY = axis.get1();

    float axisZ = axis.get2();

    float casted, xoff=0, yoff=0, zoff=0;

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

      {

      casted = (pos[3*i]+xoff)*axisX + (pos[3*i+1]+yoff)*axisY + (pos[3*i+2]+zoff)*axisZ;

      ret |= computeSingleRow(axisIndex,casted);

      }

    return ret;

    }

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

  private int computeSingleRow(int axisIndex,float casted)

    {

    int num = mNumCuts[axisIndex];

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

      {

      if( casted<mCuts[axisIndex][i] ) return (1<<i);

      }

    return (1<<num);

    }

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

// remember about the double cover or unit quaternions!

  private int mulQuat(int q1, int q2)

    {

    Static4D result = QuatHelper.quatMultiply(mQuats[q1],mQuats[q2]);

    float rX = result.get0();

    float rY = result.get1();

    float rZ = result.get2();

    float rW = result.get3();

    final float MAX_ERROR = 0.1f;

    float dX,dY,dZ,dW;

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

      {

      dX = mQuats[i].get0() - rX;

      dY = mQuats[i].get1() - rY;

      dZ = mQuats[i].get2() - rZ;

      dW = mQuats[i].get3() - rW;

      if( dX<MAX_ERROR && dX>-MAX_ERROR &&

          dY<MAX_ERROR && dY>-MAX_ERROR &&

          dZ<MAX_ERROR && dZ>-MAX_ERROR &&

          dW<MAX_ERROR && dW>-MAX_ERROR  ) return i;

      dX = mQuats[i].get0() + rX;

      dY = mQuats[i].get1() + rY;

      dZ = mQuats[i].get2() + rZ;

      dW = mQuats[i].get3() + rW;

      if( dX<MAX_ERROR && dX>-MAX_ERROR &&

          dY<MAX_ERROR && dY>-MAX_ERROR &&

          dZ<MAX_ERROR && dZ>-MAX_ERROR &&

          dW<MAX_ERROR && dW>-MAX_ERROR  ) return i;

      }

    return -1;

    }

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

  private int getMultQuat(int index1, int index2)

    {

    if( mQuatMult==null )

      {

      mQuatMult = new int[mNumQuats][mNumQuats];

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

        for(int j=0; j<mNumQuats; j++) mQuatMult[i][j] = -1;

      }

    if( index1<mNumQuats && index2<mNumQuats )

      {

      if( mQuatMult[index1][index2]==-1 ) mQuatMult[index1][index2] = mulQuat(index1,index2);

      return mQuatMult[index1][index2];

      }

android.util.Log.e("D", "error in getMulQuat: index1="+index1+" index2="+index2+" numQuats="+mNumQuats);

    return -2;

    }

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

  private boolean belongsToMove(int cubit, int axis, int layer)

    {

    return mRotRow[cubit][axis] == layer;

    }

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

// assumption: all layers have the same basicAngles!

  private int insertAllChildren(int index, byte level)

    {

    int ret = 0;

    int[] quats = getQuats(index);

    int numQuats = quats.length;

    int[] tmpQuats = new int[numQuats];

    byte newLevel = (byte)(level+1);

    boolean[] belongs = new boolean[mNumCubits];

    int quatBasis = 0;

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

      {

      for(int layer=0; layer<mNumLayers[ax]; layer++)

        {

        for(int cubit=0; cubit<mNumCubits; cubit++)

          belongs[cubit] = belongsToMove(cubit,ax,layer);

        int maxAngle = mAngles[ax][layer];

        for(int angle=1; angle<maxAngle; angle++ )

          {

          System.arraycopy(quats, 0, tmpQuats, 0, numQuats);

          int quat = quatBasis + angle;

          for(int cubit=0; cubit<mNumCubits; cubit++)

            if( belongs[cubit] )

              {

              int currQuat = tmpQuats[cubit];

              int newQuat = getMultQuat(currQuat,quat);

              tmpQuats[cubit] = newQuat;

              }

android.util.Log.e("D", "quat: "+quat+" numAxis="+mNumAxis+" numLayers="+mNumLayers[ax]+" maxAngle="+maxAngle);

          int childIndex = getIndex(tmpQuats);

          if( mTablebase.insertUnpacked(childIndex,newLevel) ) ret++;

          }

        }

      quatBasis += (mAngles[ax][0]-1);

      }

    return ret;

    }

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

  public void createTablebase()

    {

    mTablebase = new Tablebase(mSize);

    mTablebase.insertUnpacked(0,(byte)0);

    int numInserted;

    byte insertingLevel = 0;

    do

      {

      numInserted = 0;

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

        {

        byte level = mTablebase.retrieveUnpacked(i);

        if( level==insertingLevel ) numInserted += insertAllChildren(i,level);

        }

      insertingLevel++;

android.util.Log.e("D", "inserted "+numInserted+" positions at level "+insertingLevel);

      }

    while( numInserted>0 );

    }

}