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

import org.distorted.objectlib.helpers.OperatingSystemInterface;

import org.distorted.objectlib.objects.TwistyDino6;

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

public abstract class TBDino extends TablebasesPruning

{

  static final int[][] QUATS =

      {

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

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

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

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

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

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

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

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

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

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

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

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

      };

  private int[][] mAngles;

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

  public TBDino()

    {

    super();

    }

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

  public TBDino(OperatingSystemInterface os, int[] middle, int[] high)

    {

    super(os,middle,high);

    }

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

  int[][] getBasicAngles()

    {

    if( mAngles==null )

      {

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

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

      }

    return mAngles;

    }

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

  Static3D[] getRotationAxis()

    {

    return TwistyDino6.ROT_AXIS;

    }

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

  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

  boolean[][] getRotatable()

    {

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

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

    }

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

// specifically for the tablebase

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

// 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, 3, angle==1 ? 1:-1};

    if( axis==3 && layer==0 ) return new int[] { axis, 6, 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]==3 || move[1]==6 ) unrollMoves(moves,i);

      }

    }

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

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

    {

    int[] move = moves[index];

    int len = moves.length;

    if( move[1]==3 )

      {

      move[1] = 4;

      move[2] = -move[2];

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

      }

    else if( move[1]==6 )

      {

      move[1] = 1;

      move[2] = -move[2];

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

      }

    }

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

  private void unrollMove(int[] move, int axis, boolean clockwise)

    {

    switch(axis)

      {

      case 0: switch(move[0])

                {

                case 0: break;

                case 1: move[0]= (clockwise? 2 : 3); break;

                case 2: move[0]= (clockwise? 3 : 1); break;

                case 3: move[0]= (clockwise? 1 : 2); break;

                }

              break;

      case 1: switch(move[0])

                {

                case 0: move[0]= (clockwise? 3 : 2); break;

                case 1: break;

                case 2: move[0]= (clockwise? 0 : 3); break;

                case 3: move[0]= (clockwise? 2 : 0); break;

                }

              break;

      case 2: switch(move[0])

                {

                case 0: move[0]= (clockwise? 1 : 3); break;

                case 1: move[0]= (clockwise? 3 : 0); break;

                case 2: break;

                case 3: move[0]= (clockwise? 0 : 1); break;

                }

              break;

      case 3: switch(move[0])

                {

                case 0: move[0]= (clockwise? 2 : 1); break;

                case 1: move[0]= (clockwise? 0 : 2); break;

                case 2: move[0]= (clockwise? 1 : 0); break;

                case 3: break;

                }

              break;

      }

    }

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

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

    {

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

    }

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

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

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

        }

      }

    }

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

  public static int[] getPermFromQuats(int[] quats)

    {

    int[] perm = new int[12];

    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 )

          {

          perm[i] = j;

          break;

          }

      }

    return perm;

    }

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

// 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;

    }

}