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.type.Static3D;

import org.distorted.objectlib.R;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

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

public class TBCuboid323 extends TablebasesPruning

{

  private static final int[][] CORNER_MAP = new int[][]

      {

          {0,4,7,1,2,3,5,6},

          {2,0,1,6,3,4,7,5},

          {7,1,0,4,5,6,2,3},

          {1,6,2,0,7,5,3,4},

          {4,3,5,7,0,2,6,1},

          {3,2,6,5,4,0,1,7},

          {5,7,4,3,6,1,0,2},

          {6,5,3,2,1,7,4,0}

      };

  private static final int[][] EDGE_MAP = new int[][]

      {

          {0,3,5,1,4,7,2,6},

          {3,0,1,5,2,6,4,7},

          {5,1,0,3,7,4,6,2},

          {1,5,3,0,6,2,7,4},

          {2,4,7,6,0,1,3,5},

          {7,6,2,4,1,0,5,3},

          {4,2,6,7,3,5,0,1},

          {6,7,4,2,5,3,1,0}

      };

  private static final int[][] CORNER_MAP_INVERTED = new int[8][8];

  private static final int[][] EDGE_MAP_INVERTED = new int[8][8];

  static

    {

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

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

        {

        CORNER_MAP_INVERTED[i][j] = findIndex(CORNER_MAP[i],j);

        EDGE_MAP_INVERTED[i][j]   = findIndex(EDGE_MAP[i],j);

        }

    };

  private int[][] mAngles;

  private boolean mUpsideDown;

  private int[] mCornerPerm, mEdgePerm;

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

// remove perm[1] which is always equal to 1.

  public static int[] edgePermTo7(int[] perm)

    {

    int[] ret = new int[7];

    ret[0] = perm[0]; if( ret[0]>1 ) ret[0]--;

    ret[1] = perm[2]; if( ret[1]>1 ) ret[1]--;

    ret[2] = perm[3]; if( ret[2]>1 ) ret[2]--;

    ret[3] = perm[4]; if( ret[3]>1 ) ret[3]--;

    ret[4] = perm[5]; if( ret[4]>1 ) ret[4]--;

    ret[5] = perm[6]; if( ret[5]>1 ) ret[5]--;

    ret[6] = perm[7]; if( ret[6]>1 ) ret[6]--;

    return ret;

    }

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

// reverse the above

  private static int[] edgePermTo8(int[] perm)

    {

    int[] ret = new int[8];

    ret[0] = perm[0]; if( ret[0]>=1 ) ret[0]++;

    ret[1] = 1;

    ret[2] = perm[1]; if( ret[2]>=1 ) ret[2]++;

    ret[3] = perm[2]; if( ret[3]>=1 ) ret[3]++;

    ret[4] = perm[3]; if( ret[4]>=1 ) ret[4]++;

    ret[5] = perm[4]; if( ret[5]>=1 ) ret[5]++;

    ret[6] = perm[5]; if( ret[6]>=1 ) ret[6]++;

    ret[7] = perm[6]; if( ret[7]>=1 ) ret[7]++;

    return ret;

    }

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

  public TBCuboid323()

    {

    super();

    allocate();

    }

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

  public TBCuboid323(OperatingSystemInterface os)

    {

    super(os,new int[] {R.raw.cu_323_pruning7 ,R.raw.cu_323_pruning8 },

             new int[] {R.raw.cu_323_pruning17,R.raw.cu_323_pruning18} );

    allocate();

    }

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

  private void allocate()

    {

    mCornerPerm = new int[8];

    mEdgePerm = new int[7];

    }

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

  public void initialize()

    {

    mUpsideDown = false;

    }

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

  int[][] getBasicAngles()

    {

    if( mAngles==null )

      {

      int[] tmp2 = {2,2,2};

      int[] tmp4 = {4,4};

      mAngles = new int[][] { tmp2,tmp4,tmp2 };

      }

    return mAngles;

    }

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

  Static3D[] getRotationAxis()

    {

    return new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

    }

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

  float[][] getPosition()

    {

    return new float[][]

      {

        { -1.0f, -0.5f, -1.0f },

        { -1.0f, -0.5f,  1.0f },

        { -1.0f,  0.5f, -1.0f },

        { -1.0f,  0.5f,  1.0f },

        {  1.0f, -0.5f, -1.0f },

        {  1.0f, -0.5f,  1.0f },

        {  1.0f,  0.5f, -1.0f },

        {  1.0f,  0.5f,  1.0f },

        {  0.0f, -0.5f, -1.0f },

        {  0.0f, -0.5f,  1.0f },

        {  0.0f,  0.5f, -1.0f },

        {  0.0f,  0.5f,  1.0f },

        { -1.0f, -0.5f,  0.0f },

        { -1.0f,  0.5f,  0.0f },

        {  1.0f, -0.5f,  0.0f },

        {  1.0f,  0.5f,  0.0f },

        {  0.0f,  0.5f,  0.0f },

        {  0.0f, -0.5f,  0.0f },

      };

    }

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

  float[][] getCuts()

    {

    return new float[][] { {-0.5f,0.5f}, {0.0f}, {-0.5f,0.5f} };

    }

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

  boolean[][] getRotatable()

    {

    return new boolean[][] { {true,false,true},{false,true},{true,true,false} };

    }

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

// purely for speedup

  @Override

  void computeRow(float[] pos, int quat, int[] output)

    {

    float[] q = mQuats[quat];

    float qx = q[0];

    float qy = q[1];

    float qz = q[2];

    float qw = q[3];

    float rx = pos[0];

    float ry = pos[1];

    float rz = pos[2];

    mTmp[0] = qx - rz*qy + ry*qz + rx*qw;

    mTmp[1] = qy + rz*qx + ry*qw - rx*qz;

    mTmp[2] = qz + rz*qw - ry*qx + rx*qy;

    mTmp[3] = qw - rz*qz - ry*qy - rx*qx;

    float x = qw*mTmp[0] + qz*mTmp[1] - qy*mTmp[2] - qx*mTmp[3];

    float y = qw*mTmp[1] - qz*mTmp[0] - qy*mTmp[3] + qx*mTmp[2];

    float z = qw*mTmp[2] - qz*mTmp[3] + qy*mTmp[0] - qx*mTmp[1];

    output[0] = (x<-0.5f ? 1 : (x<0.5f ? 2:4));

    output[1] = (y<0 ? 1:2);

    output[2] = (z<-0.5f ? 1 : (z<0.5f ? 2:4));

    }

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

// we map the move (axis=2, middle layer) to move (axis=2,both middle and back layers).

// this way we can imitate move of the front layer (which we do not want to move because

// the edge1 piece has to always stay in its place)

  @Override

  int computeBitLayer(int ax, int layer)

    {

    if( ax!=2 ) return (1<<layer);

    switch(layer)

      {

      case 0 : return 1;

      case 1 : return 3;

      default: return 4;

      }

    }

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

// this is too slow to be used for scrambling - scramble the 3x3x2 the old way.

  @Override

  public boolean useForScrambling()

    {

    return false;

    }

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

// specifically for the tablebase

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

// now turn the (ax=2, middle and back layer) artificial moves [ introduced by computeBitLayer)

// back to the natural (ax=2, front layer). Turn the whole thing upside down each time we do it.

  @Override

  int[] newMove(int axis, int layer, int angle)

    {

    if( axis==2 )

      {

      if( layer==1 )

        {

        mUpsideDown = !mUpsideDown;

        return new int[] { axis, 4, angle };

        }

      }

    else if( mUpsideDown )

      {

      if( axis==0 ) layer=2-layer;

      if( axis==1 ) { layer=1-layer; angle = 4-angle; }

      }

    int maxAngle = mAngles[axis][layer];

    angle = maxAngle-angle;

    if( angle> 0.5f*maxAngle ) angle -= maxAngle;

    return new int[] { axis, (1<<layer), angle };

    }

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

// 8!*8!/4 --> https://www.jaapsch.net/puzzles/domino.htm

  int getSize()

    {

    return 406425600;

    }

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

  int getMinScramble()

    {

    return 13;

    }

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

  int[] getMidPruningLevels()

    {

    return new int[] {7,8};

    }

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

  int[] getHighPruningLevels()

    {

    return new int[] {17,18};

    }

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

  int getGodsNumber()

    {

    return 18;

    }

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

  boolean moveCanProceed(int lastA, int lastR, int currA, int currR)

    {

    return (lastA!=currA) || (lastR!=currR);

    }

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

  private static int findIndex(int[] table, int value)

    {

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

      if( table[i]==value ) return i;

    return -1;

    }

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

  private int centersInverted(int[] quats)

    {

    int q = quats[16];

    return (q==0 || q==2 || q==3 || q==4) ? 0 : 1;

    }

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

  public static int[] quatsFromPermutations(int[] corner, int[] edge8, int centers)

    {

    int[] quats = new int[18];

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

      {

      int q = CORNER_MAP[i][corner[i]];

      quats[i] = q;

      }

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

      {

      int q = EDGE_MAP[i][edge8[i]];

      quats[i+8] = q;

      }

    if( centers==0 )

      {

      quats[16]=0;

      quats[17]=0;

      }

    else

      {

      quats[16]=5;

      quats[17]=5;

      }

    return quats;

    }

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

  private static void cornerFromQuats(int[] corner_perm, int[] quats)

    {

    for(int i=0; i<8; i++) corner_perm[i] = CORNER_MAP_INVERTED[i][quats[i]];

    }

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

  private static void edgeFromQuats(int[] edge_perm, int[] quats)

    {

    edge_perm[0] = EDGE_MAP_INVERTED[0][quats[ 8]]; if(edge_perm[0]>1) edge_perm[0]--;

    edge_perm[1] = EDGE_MAP_INVERTED[2][quats[10]]; if(edge_perm[1]>1) edge_perm[1]--;

    edge_perm[2] = EDGE_MAP_INVERTED[3][quats[11]]; if(edge_perm[2]>1) edge_perm[2]--;

    edge_perm[3] = EDGE_MAP_INVERTED[4][quats[12]]; if(edge_perm[3]>1) edge_perm[3]--;

    edge_perm[4] = EDGE_MAP_INVERTED[5][quats[13]]; if(edge_perm[4]>1) edge_perm[4]--;

    edge_perm[5] = EDGE_MAP_INVERTED[6][quats[14]]; if(edge_perm[5]>1) edge_perm[5]--;

    edge_perm[6] = EDGE_MAP_INVERTED[7][quats[15]]; if(edge_perm[6]>1) edge_perm[6]--;

    }

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

  public int[] getQuats(int index)

    {

    int cornerPermNum = (index%40320);

    index /= 40320;

    int centers = (index%2);

    int edgePermNum = index/2;

    int[] corner_perm = new int[8];

    TablebaseHelpers.getPermutationFromNum(corner_perm,8,cornerPermNum);

    int[] edge_perm7 = new int[7];

    TablebaseHelpers.getPermutationFromNum(edge_perm7,7,edgePermNum);

    int[] edge_perm8 = edgePermTo8(edge_perm7);

    return quatsFromPermutations(corner_perm,edge_perm8,centers);

    }

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

  public int getIndex(int[] quats)

    {

    int centers = centersInverted(quats);

    cornerFromQuats(mCornerPerm,quats);

    int corner_perm_num = TablebaseHelpers.computePermutationNum(mCornerPerm);

    edgeFromQuats(mEdgePerm,quats);

    int edge_perm_num = TablebaseHelpers.computePermutationNum(mEdgePerm);

    return corner_perm_num + 40320*( centers + 2*edge_perm_num);

    }

}