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

import org.distorted.objectlib.R;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

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

public class TBPyraminxDiamond extends TablebasesPruning

{

  private static final int[][] CORNER_QUATS =

      {

          {0,6,5,4},

          {0,4,5,6},

          {0,3,2,1},

          {0,9,8,7},

          {0,7,8,9},

          {0,1,2,3},

      };

  private static final int[][][] CENTER_QUATS =

      {

          { {21,15, 0}, {10,13, 5}, {17, 9, 3}, {16,18,11}, {19, 1, 6}, { 2,12,23}, { 7,14, 4}, { 8,20,22} },

          { { 5,23,20}, { 0,22,12}, {19,16,14}, { 7,17, 1}, { 4,11, 9}, {10, 8,15}, { 6, 3,18}, {21, 2,13} },

          { { 1,17, 7}, {14,16,19}, { 0,12,22}, { 5,20,23}, {13, 2,21}, { 6,18, 3}, {15, 8,10}, { 4, 9,11} },

          { {18,11,16}, { 9, 3,17}, { 5,10,13}, { 0,21,15}, {20,22, 8}, { 4, 7,14}, {12,23, 2}, { 6,19, 1} },

          { { 4,19, 3}, { 6, 7,11}, {15, 2,20}, {13, 8,12}, { 0,10,23}, { 1,16, 9}, { 5,21,22}, {14,17,18} },

          { {10, 2,22}, {21, 8,23}, { 4, 1,18}, { 6,14, 9}, { 7,16, 3}, { 0,13,20}, {19,17,11}, { 5,15,12} },

          { { 6,14, 9}, { 4, 1,18}, {21, 8,23}, {10, 2,22}, { 5,15,12}, {19,17,11}, { 0,13,20}, { 7,16, 3} },

          { {12, 8,13}, {20, 2,15}, { 6,11, 7}, { 4, 3,19}, {18,17,14}, { 5,22,21}, { 9,16, 1}, { 0,23,10} },

      };

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

  public TBPyraminxDiamond()

    {

    super();

    }

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

  public TBPyraminxDiamond(OperatingSystemInterface os)

    {

    super(os, new int[] {R.raw.pdia_3_pruning3,R.raw.pdia_3_pruning4}, new int[] {R.raw.pdia_3_pruning10});

    }

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

  int[][] getBasicAngles()

    {

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

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

    }

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

  Static3D[] getRotationAxis()

    {

    return new Static3D[]

         {

         new Static3D(SQ2/2, 0, SQ2/2),

         new Static3D(    0, 1,     0),

         new Static3D(SQ2/2, 0,-SQ2/2)

         };

    }

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

  float[][] getPosition()

    {

    float B0 = 1.5f*SQ2;

    float C0 = 1.5f;

    float A  = 1.03f;

    float B1 = 0.5f*SQ2*A;

    float C1 = A;

    return new float[][]

         {

             {  0, B0,  0 },

             {  0,-B0,  0 },

             { C0,  0, C0 },

             { C0,  0,-C0 },

             {-C0,  0, C0 },

             {-C0,  0,-C0 },

             {  0, B1, C1 },

             {  0, B1,-C1 },

             {  0,-B1, C1 },

             {  0,-B1,-C1 },

             { C1, B1,  0 },

             { C1,-B1,  0 },

             {-C1, B1,  0 },

             {-C1,-B1,  0 },

         };

    }

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

  float[][] getCuts()

    {

    float C = 0.5f*SQ2;

    float[] cut = { -C,C};

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

    }

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

  boolean[][] getRotatable()

    {

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

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

    }

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

// specifically for the tablebase

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

// 4^6 - corner twists; 8! - center permutation; divide by 2 because parity of permutation must

// agree with parity of total twists = (4^6)*8! / 2 = 82.575.360

  int getSize()

    {

    return 82575360;

    }

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

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

    }

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

  private int findIndex1(int[] table, int entry)

    {

    int len = table.length;

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

      if( table[i]==entry ) return i;

    return -1;

    }

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

  private int findIndex2(int[][] table, int entry)

    {

    int len = table.length;

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

      {

      int[] t = table[i];

      if( t[0]==entry || t[1]==entry || t[2]==entry ) return i;

      }

    return -1;

    }

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

  public int[] getQuats(int index)

    {

    int[] quats = new int[14];

    int[] perm  = new int[8];

    int[] twist = new int[6];

    int centers_perm_num = index/2048;

    int total_twist = index%2048;

    TablebaseHelpers.getPermutationFromNum(perm,8,centers_perm_num);

    boolean even = TablebaseHelpers.permutationIsEven(perm);

    for(int i=0; i<5; i++) { twist[i] = total_twist%4; total_twist /=4; }

    int total = twist[0]+twist[1]+twist[2]+twist[3]+twist[4]+(even?0:1);

    twist[5] = 2*total_twist + (total%2);

    for(int i=0; i<6; i++) quats[i  ] = CORNER_QUATS[i][twist[i]];

    for(int i=0; i<8; i++) quats[i+6] = CENTER_QUATS[i][perm[i]][0];

    return quats;

    }

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

  public int getIndex(int[] quats)

    {

    int[] twist = new int[6];

    int[] perm  = new int[8];

    for(int i=0; i<6; i++) twist[i] = findIndex1(CORNER_QUATS[i],quats[i]);

    for(int i=0; i<8; i++) perm[i]  = findIndex2(CENTER_QUATS[i],quats[i+6]);

    int centers_perm_num = TablebaseHelpers.computePermutationNum(perm);

    int total_twist = twist[0]+ 4*(twist[1]+ 4*(twist[2]+ 4*(twist[3]+ 4*(twist[4]+ 4*(twist[5]>1 ? 1:0)))));

    return total_twist + 2048*centers_perm_num;

    }

}