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 static org.distorted.objectlib.main.TwistyObject.SQ3;

import android.content.res.Resources;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.R;

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

public class TBDino6 extends TablebasesPruning

{

  private static final int INDEX_INVERTED = 13379863; // quats (0,10,0,10, 11,11,11,11, 0,10,0,10)

  private static final int[][] QUATS =

      {

          {0,2,10,8, 1,4,6,7,   11,5,9,3},

          {1,0,6,10, 2,5,8,3,   7,9,4,11},

          {10,5,0,3, 7,6,4,1,   9,2,11,8},

          {7,10,4,0, 5,2,3,8,   1,11,6,9},

          {2,1,8,6,  0,9,10,11, 3,4,5,7 },

          {3,6,5,1,  9,0,11,10, 2,7,8,4 },

          {5,7,3,4,  10,11,0,9, 8,6,2,1 },

          {8,4,2,7,  11,10,9,0, 5,1,3,6 },

          {11,8,9,2, 4,1,7,6,   0,3,10,5},

          {6,9,1,11, 3,8,5,2,   4,0,7,10},

          {9,3,11,5, 6,7,1,4,   10,8,0,2},

          {4,11,7,9, 8,3,2,5,   6,10,1,0}

      };

  private int[][] mAngles;

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

  public TBDino6()

    {

    super();

    }

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

  public TBDino6(Resources res)

    {

    super(res,new int[] {R.raw.dino_3_pruning3,R.raw.dino_3_pruning4},new int[] {R.raw.dino_3_pruning10});

    }

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

  int[][] getBasicAngles()

    {

    if( mAngles==null )

      {

      int[] tmp = {3,3,3};

      mAngles = new int[][] { tmp,tmp,tmp,tmp };

      }

    return mAngles;

    }

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

  Static3D[] getRotationAxis()

    {

    return new Static3D[]

         {

           new Static3D( SQ3/3, SQ3/3, SQ3/3),

           new Static3D( SQ3/3, SQ3/3,-SQ3/3),

           new Static3D( SQ3/3,-SQ3/3, SQ3/3),

           new Static3D( SQ3/3,-SQ3/3,-SQ3/3)

         };

    }

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

  float[][] getPosition()

    {

    return new float[][]

         {

             { 0.0f, 1.5f, 1.5f },

             { 1.5f, 0.0f, 1.5f },

             { 0.0f,-1.5f, 1.5f },

             {-1.5f, 0.0f, 1.5f },

             { 1.5f, 1.5f, 0.0f },

             { 1.5f,-1.5f, 0.0f },

             {-1.5f,-1.5f, 0.0f },

             {-1.5f, 1.5f, 0.0f },

             { 0.0f, 1.5f,-1.5f },

             { 1.5f, 0.0f,-1.5f },

             { 0.0f,-1.5f,-1.5f },

             {-1.5f, 0.0f,-1.5f }

         };

    }

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

  float[][] getCuts()

    {

    float[] cut = new float[] { -SQ3/3, SQ3/3 };

    return new float[][] { cut,cut,cut,cut };

    }

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

// exclude the middle layer and movements of edge[0].

  boolean[][] getRotatable()

    {

    boolean[] tmp = {true,false,true};

    return new boolean[][] { tmp,tmp,tmp,tmp };

    }

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

// specifically for the tablebase

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

// two solved positions: original and mirrored (left face swapped with right)

  @Override

  int[] getSolvedIndices()

    {

    return new int[] {0,INDEX_INVERTED};

    }

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

// ditto

  @Override

  boolean isSolved(int index)

    {

    return index==0 || index==INDEX_INVERTED;

    }

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

// we can never really move the top-front edge, because if we do so, we would also rotate the

// rotation axis themselves! (see getIndex() where the cubit quats are normalized so that quat[0]

// - i.e. the front-top edge - is always 0).

// That's why map the moves (0,2,X) to (0,0&1,-X) and (3,0,X) to (3,1&2,-X)

  @Override

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

    {

    if( axis==0 && layer==2 ) return new int[] { axis, (1<<0)+(1<<1), angle==1 ? 1:-1};

    if( axis==3 && layer==0 ) return new int[] { axis, (1<<1)+(1<<2), angle==1 ? 1:-1};

    int maxAngle = mAngles[axis][layer];

    angle = maxAngle-angle;

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

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

    }

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

// here we change back the mapping introduced by 'newMove()'

  @Override

  void convertMoves(int[][] moves)

    {

    for(int[] move : moves )

      {

      int[] newMove = newMove(move[0],move[1],move[2]);

      move[0] = newMove[0];

      move[1] = newMove[1];

      move[2] = newMove[2];

      }

/*

    int len = moves.length;

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

      {

      int[] move = moves[i];

      if( move[1]==((1<<0)+(1<<1)) || move[1]==((1<<1)+(1<<2)) ) unrollMoves(moves,i);

      }

 */

    }

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

  private void unrollMoves(int[][] moves, int index)

    {

    int caseUnroll=0;

    int[] move = moves[index];

    if( move[1]==((1<<0)+(1<<1)) )

      {

      move[1] = (1<<2);

      move[2] = -move[2];

      caseUnroll = move[2]>0 ? 0:1;

      }

    else if( move[1]==((1<<1)+(1<<2)) )

      {

      move[1] = (1<<0);

      move[2] = -move[2];

      caseUnroll = move[2]>0 ? 2:3;

      }

    int len = moves.length;

    for(int i=index+1; i<len; i++) unrollMove(moves[i],caseUnroll);

    }

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

  private void unrollMove(int[] move, int caseUnroll)

    {

    int ax = move[0];

    int la = move[1];

    switch(caseUnroll)

      {

      case 0: android.util.Log.e("D", "case 0 ax "+ax);

              switch(ax)

                {

                case 0: break;

                case 1: move[0]=3; move[1]=negate(la); break;

                case 2: move[0]=1; break;

                case 3: move[0]=2; move[1]=negate(la); break;

                }

              break;

      case 1: android.util.Log.e("D", "case 1 ax "+ax);

              switch(ax)

                {

                case 0: break;

                case 1: move[0]=2; break;

                case 2: move[0]=3; move[1]=negate(la); break;

                case 3: move[0]=1; move[1]=negate(la); break;

                }

              break;

      case 2: android.util.Log.e("D", "case 2 ax "+ax);

              switch(ax)

                {

                case 0: move[0]=1; move[1]=negate(la); break;

                case 1: move[0]=2; break;

                case 2: move[0]=0; move[1]=negate(la); break;

                case 3: break;

                }

              break;

      case 3: android.util.Log.e("D", "case 3 ax "+ax);

              switch(ax)

                {

                case 0: move[0]=2; move[1]=negate(la); break;

                case 1: move[0]=0; move[1]=negate(la); break;

                case 2: move[0]=1; break;

                case 3: break;

                }

              break;

      }

    }

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

  private int negate(int layer)

    {

    return 7-layer;

    }

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

  int getSize()

    {

    return 19958400;  // see https://www.jaapsch.net/puzzles/dinocube.htm

    }

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

  int getMinScramble()

    {

    return 8;

    }

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

  int[] getMidPruningLevels()

    {

    return new int[] {3,4};

    }

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

  int[] getHighPruningLevels()

    {

    return new int[] {10};

    }

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

  int getGodsNumber()

    {

    return 10;

    }

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

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

    {

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

    }

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

  public static int getIndexFromPerm(int[] perm)

    {

    int[] perm11 = new int[11];

    for(int i=0; i<11; i++) perm11[i] = perm[i+1]-1;

    return TablebaseHelpers.computeEvenPermutationNum(perm11);

    }

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

// in-place!

  private int[] getPermFromQuats(int[] quats)

    {

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

      {

      int[] Q = QUATS[i];

      int quat = quats[i];

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

        if( Q[j]==quat )

          {

          quats[i] = j;

          break;

          }

      }

    return quats;

    }

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

// in-place!

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

    {

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

      {

      int p = perm[i];

      perm[i] = QUATS[i][p];

      }

    return perm;

    }

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

// we rotate the whole thing so that quat[0] is always 0.

  private void normalizeQuats(int[] quats)

    {

    if( quats[0]!=0 )

      {

      int inverted = getInvertedQuat(quats[0]);

      quats[0] = 0;

      for(int i=1; i<12; i++)

        {

        int index = quats[i];

        quats[i] = getMultQuat(inverted,index);

        }

      }

    }

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

  int[] getQuats(int index)

    {

    int[] perm11 = new int[11];

    TablebaseHelpers.getEvenPermutationFromNum(perm11,index);

    int[] perm = new int[12];

    for(int i=1; i<12; i++) perm[i] = perm11[i-1]+1;

    return getQuatsFromPerm(perm);

    }

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

  int getIndex(int[] quats)

    {

    normalizeQuats(quats);

    int[] perm = getPermFromQuats(quats);

    return getIndexFromPerm(perm);

    }

}