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.SQ2;

import static org.distorted.objectlib.main.TwistyObject.SQ3;

import static org.distorted.objectlib.main.TwistyObject.SQ6;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.R;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

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

public class TBSkewbDiamond extends TablebasesAbstract

{

  private static final int[][][] FREE_CENTER =

      {

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

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

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

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

      };

  public static final int[][][] CORNER_QUATS =

      {

          { {0,9},{2,4},{10,11},{8,6},{1,5},{3,7} },   // order of each pair determines the twist.

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

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

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

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

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

      };

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

  public TBSkewbDiamond()

    {

    super();

    }

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

  public TBSkewbDiamond(OperatingSystemInterface os)

    {

    super(os, R.raw.diam_2_tablebase);

    }

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

  int[][] getBasicAngles()

    {

    int[] tmp = {3,3};

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

    }

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

  Static3D[] getRotationAxis()

    {

    return new Static3D[]

         {

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

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

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

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

         };

    }

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

  float[][] getPosition()

    {

    return new float[][]

         {

             { 0.5f, 0.0f,  0.5f},

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

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

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

             { 0.0f, SQ2/2, 0.0f},

             { 0.0f,-SQ2/2, 0.0f},

             { 0.0f, SQ2/4, 0.5f},

             { 0.5f, SQ2/4, 0.0f},

             { 0.0f, SQ2/4,-0.5f},

             {-0.5f, SQ2/4, 0.0f},

             { 0.0f,-SQ2/4, 0.5f},

             { 0.5f,-SQ2/4, 0.0f},

             { 0.0f,-SQ2/4,-0.5f},

             {-0.5f,-SQ2/4, 0.0f}

         };

    }

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

  float[][] getCuts()

    {

    float[] cut = { 0.0f };

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

    }

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

  boolean[][] getRotatable()

    {

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

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

    }

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

// specifically for the tablebase

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

  int getSize()

    {

    return 138240;  // see https://www.jaapsch.net/puzzles/diamond.htm

    }

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

  int getMinScramble()

    {

    return 8;

    }

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

  private int computeCenterQuat(int originalLocation, int newLocation)

    {

    return FREE_CENTER[originalLocation][newLocation][0];

    }

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

  private void computeCenterPerm(int[] output, int q0, int q1, int q2, int q3)

    {

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

      {

      int[] q = FREE_CENTER[0][j];

      if( q[0]==q0 || q[1]==q0 || q[2]==q0 ) { output[0]=j; break; }

      }

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

      {

      int[] q = FREE_CENTER[1][j];

      if( q[0]==q1 || q[1]==q1 || q[2]==q1 ) { output[1]=j; break; }

      }

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

      {

      int[] q = FREE_CENTER[2][j];

      if( q[0]==q2 || q[1]==q2 || q[2]==q2 ) { output[2]=j; break; }

      }

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

      {

      int[] q = FREE_CENTER[3][j];

      if( q[0]==q3 || q[1]==q3 || q[2]==q3 ) { output[3]=j; break; }

      }

    }

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

  private int computeCornerQuat(int originalLocation, int newLocation, int twist)

    {

    return CORNER_QUATS[originalLocation][newLocation][twist];

    }

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

  private int computeCornerPerm(int[] output, int[] quats)

    {

    int totalTwist = 0;

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

      {

      int q = quats[i];

      int[][] perm = CORNER_QUATS[i];

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

        {

        int[] p = perm[j];

        if( p[0]==q ) { output[i]=j;                               break; }

        if( p[1]==q ) { output[i]=j; if( i<5 ) totalTwist+=(1<<i); break; }

        }

      }

    return totalTwist;

    }

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

  public int[] getQuats(int index)

    {

    int centers_perm_num = (index%12);

    index /= 12;

    int totalTwist = (index%32);

    int corners_perm_num = (index/32);

    int[] centers_perm = new int[4];

    TablebaseHelpers.getEvenPermutationFromNum(centers_perm,centers_perm_num);

    int[] corners_perm = new int[6];

    TablebaseHelpers.getEvenPermutationFromNum(corners_perm,corners_perm_num);

    int[] quats = new int[14];

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

      {

      int twist = (totalTwist%2);

      totalTwist /= 2;

      quats[i] = computeCornerQuat(i,corners_perm[i],twist);

      }

    quats[ 6] = computeCenterQuat(0,centers_perm[0]);

    quats[ 8] = computeCenterQuat(1,centers_perm[1]);

    quats[11] = computeCenterQuat(2,centers_perm[2]);

    quats[13] = computeCenterQuat(3,centers_perm[3]);

    return quats;

    }

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

  public int getIndex(int[] quats)

    {

    int[] center_perm = new int[4];

    computeCenterPerm(center_perm, quats[6],quats[8],quats[11],quats[13]);

    int centers_perm_num = TablebaseHelpers.computeEvenPermutationNum(center_perm);

    int[] corners_perm = new int[6];

    int totalTwist = computeCornerPerm(corners_perm,quats);

    int corners_perm_num = TablebaseHelpers.computeEvenPermutationNum(corners_perm);

    return centers_perm_num + 12*(totalTwist + 32*corners_perm_num);

    }

}