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;

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

public class TBDino6 extends TablebasesAbstract

{

  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}

      };

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

  public TBDino6()

    {

    super();

    }

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

  public TBDino6(Resources res)

    {

    super(res,org.distorted.objectlib.R.raw.dino_3_tablebase);

    }

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

  int[][] getBasicAngles()

    {

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

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

    }

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

  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

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

  int getSize()

    {

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

    }

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

  int getMinScramble()

    {

    return 9;

    }

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

  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!

  private 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)

    {

//int[] q1 = new int[12];

//for(int i=0; i<12; i++) q1[i] = quats[i];

    normalizeQuats(quats);

//int[] q2 = new int[12];

//for(int i=0; i<12; i++) q2[i] = quats[i];

    int[] perm = getPermFromQuats(quats);

    int ret = getIndexFromPerm(perm);

/*

    if( ret<0 )

      {

      StringBuilder sb = new StringBuilder();

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

        {

        sb.append(' ');

        sb.append(q1[i]);

        }

      android.util.Log.e("D", "getIndex: returning="+ret+" orig quats: "+sb);

      StringBuilder sb1 = new StringBuilder();

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

        {

        sb1.append(' ');

        sb1.append(q2[i]);

        }

      android.util.Log.e("D", "getIndex: returning="+ret+" norm quats: "+sb1);

      StringBuilder sb2 = new StringBuilder();

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

        {

        sb2.append(' ');

        sb2.append(perm[i]);

        }

      android.util.Log.e("D", "getIndex: returning="+ret+" perm: "+sb2);

      }

*/

    return ret;

    }

}