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.helpers.OperatingSystemInterface;

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

public class TBCuboid232 extends TablebasesAbstract

{

  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}

      };

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

  public TBCuboid232()

    {

    super();

    }

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

  public TBCuboid232(OperatingSystemInterface os)

    {

    super(os,org.distorted.objectlib.R.raw.cu_232_tablebase);

    }

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

  int[][] getBasicAngles()

    {

    int[] tmp2 = {2,2};

    int[] tmp4 = {4,4,4};

    return new int[][] { tmp2,tmp4,tmp2 };

    }

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

  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[][]

      {

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

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

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

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

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

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

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

        {  0.5f,  1.0f,  0.5f },

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

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

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

        {  0.5f,  0.0f,  0.5f },

      };

    }

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

  float[][] getCuts()

    {

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

    }

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

  boolean[][] getRotatable()

    {

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

    }

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

// specifically for the tablebase

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

// 8!*3! --> https://www.jaapsch.net/puzzles/cube223.htm

  int getSize()

    {

    return 241920;

    }

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

  int getMinScramble()

    {

    return 12;

    }

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

  private void getCornerQuats(int[] output, int[] perm)

    {

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

      output[i] = CORNER_MAP[i][perm[i]];

    }

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

  private int[] getCornerPerm(int[] quats)

    {

    int[] output = new int[8];

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

      {

      int quat = quats[i];

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

        {

        if( CORNER_MAP[i][j]==quat )

          {

          output[i]=j;

          break;

          }

        }

      }

    return output;

    }

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

  private void getEdgeQuats(int[] output, int[] perm)

    {

    switch(perm[0])

      {

      case 0: output[8] = 0; break;

      case 2: output[8] = 5; break;

      case 3: output[8] = 3; break;

      default: android.util.Log.e("D", "getEdgeQuats ERROR1");

      }

    output[9] = 0;

    switch(perm[2])

      {

      case 0: output[10] = 5; break;

      case 2: output[10] = 0; break;

      case 3: output[10] = 1; break;

      default: android.util.Log.e("D", "getEdgeQuats ERROR2");

      }

    switch(perm[3])

      {

      case 0: output[11] = 3; break;

      case 2: output[11] = 1; break;

      case 3: output[11] = 0; break;

      default: android.util.Log.e("D", "getEdgeQuats ERROR3");

      }

    }

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

  private int[] getEdgePerm(int[] quats)

    {

    int[] output = new int[4];

    switch(quats[8])

      {

      case 0: output[0] = 0; break;

      case 5: output[0] = 2; break;

      case 3: output[0] = 3; break;

      default: android.util.Log.e("D", "getEdgePerm ERROR1");

      }

    output[1] = 1;

    switch(quats[10])

      {

      case 0: output[2] = 2; break;

      case 1: output[2] = 3; break;

      case 5: output[2] = 0; break;

      default: android.util.Log.e("D", "getEdgePerm ERROR2");

      }

    switch(quats[11])

      {

      case 0: output[3] = 3; break;

      case 1: output[3] = 2; break;

      case 3: output[3] = 0; break;

      default: android.util.Log.e("D", "getEdgePerm ERROR3");

      }

    return output;

    }

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

  private int[] uncollapseEdgePerm(int[] perm)

    {

    int[] ret = new int[4];

    ret[0] = perm[0];

    ret[1] = 1;

    ret[2] = perm[1];

    ret[3] = perm[2];

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

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

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

    return ret;

    }

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

  public int[] getQuats(int index)

    {

    int[] quats = new int[12];

    int edge_perm_num = index%6;

    int corn_perm_num = index/6;

    int[] edge_perm = new int[3];

    TablebaseHelpers.getPermutationFromNum(edge_perm,3,edge_perm_num);

    int[] corn_perm = new int[8];

    TablebaseHelpers.getPermutationFromNum(corn_perm,8,corn_perm_num);

    int[] edge_perm2 = uncollapseEdgePerm(edge_perm);

    getCornerQuats(quats,corn_perm);

    getEdgeQuats(quats,edge_perm2);

    return quats;

    }

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

  private int[] collapseEdgePerm(int[] perm)

    {

    int[] ret = new int[3];

    ret[0] = perm[0];

    ret[1] = perm[2];

    ret[2] = perm[3];

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

    if( ret[1]>1 ) ret[1]--;

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

    return ret;

    }

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

  public int getIndex(int[] quats)

    {

    int[] edge_perm = getEdgePerm(quats);

    int[] corn_perm = getCornerPerm(quats);

    int[] edge_perm2= collapseEdgePerm(edge_perm); // edge1 is fixed!

    int corn_perm_num = TablebaseHelpers.computePermutationNum(corn_perm);

    int edge_perm_num = TablebaseHelpers.computePermutationNum(edge_perm2);

    return edge_perm_num + 6*corn_perm_num;

    }

}