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;

import org.distorted.objectlib.R;

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

public class TBSkewb extends TablebasesAbstract

{

  private static final int[][][] centerQuats =

    {

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

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

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

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

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

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

    };

  // [1][] are the 3 quats the 1st 'fixed' corner will have when 'fakeTwisted' (which in case of

  // the fixed corners is the same as the final twist) with respectively twist 0,1,2.

  private static final int[][] fixedQuats = { {0,1,2},{0,7,8},{0,6,5},{0,4,3} };

  // [1][2][] are the 3 quats the 1st free corner, when permuted to the location of the 2nd corner,

  // will have when it is 'fakeTwisted' with fakeTwist 0,1,2.

  // fakeTwist is an intermediate twist which needs yet to be translated to the final twist of the

  // corners (which needs to sum up to something divisible by 3).

  private static final int[][][] freeQuats=

    {

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

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

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

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

    };

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

  public TBSkewb()

    {

    super();

    }

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

  public TBSkewb(Resources res)

    {

    super(res, R.raw.pyra_3_tablebase);

    }

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

  int[][] getBasicAngles()

    {

    int[] tmp = {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[][]

         {

             { 1, 1, 1 },

             { 1, 1,-1 },

             { 1,-1, 1 },

             { 1,-1,-1 },

             {-1, 1, 1 },

             {-1, 1,-1 },

             {-1,-1, 1 },

             {-1,-1,-1 },

             { 0, 0, 1 },

             { 0, 0,-1 },

             { 0, 1, 0 },

             { 0,-1, 0 },

             { 1, 0, 0 },

             {-1, 0, 0 }

         };

    }

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

  float[][] getCuts()

    {

    float[] cut = {0};

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

    }

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

  boolean[][] getRotatable()

    {

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

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

    return new boolean[][] { t1,t2,t2,t1 };

    }

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

// specifically for the tablebase

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

  int getSize()

    {

    return 3149280;  // see https://www.jaapsch.net/puzzles/skewb.htm

    }

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

  int getMinScramble()

    {

    return 9;

    }

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

  public static void fillInQuats(int[] output, int[] perm, int[] twist)

    {

    output[0] = fixedQuats[0][twist[0]];

    output[1] = freeQuats[0][perm[0]][twist[1]];

    output[2] = freeQuats[1][perm[1]][twist[2]];

    output[3] = fixedQuats[1][twist[3]];

    output[4] = freeQuats[2][perm[2]][twist[3]];

    output[5] = fixedQuats[2][twist[5]];

    output[6] = fixedQuats[3][twist[6]];

    output[7] = freeQuats[3][perm[3]][twist[7]];

    }

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

  public static int computeLocation(int quat)

    {

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

      {

      int[] q = freeQuats[0][i];

      if( quat==q[0] || quat==q[1] || quat==q[2] ) return i;

      }

    android.util.Log.e("D", "error in computeLocation, quat="+quat);

    return -1;

    }

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

  private static int retFixed(int index, int quat)

    {

    int[] qs = fixedQuats[index];

    if( quat==qs[0]) return 0;

    if( quat==qs[1]) return 1;

    if( quat==qs[2]) return 2;

    android.util.Log.e("D", "error in retFixed, index="+index+" quat="+quat);

    return -1;

    }

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

  private static int retFree(int index, int quat)

    {

    int[][] qs = freeQuats[index];

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

      {

      if( quat==qs[i][0]) return 0;

      if( quat==qs[i][1]) return 1;

      if( quat==qs[i][2]) return 2;

      }

    android.util.Log.e("D", "error in retFree, index="+index+" quat="+quat);

    return -1;

    }

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

// In case of the four 'fixed' corners (0,3,5,6) which do not change their location,

// the twist is natural: 0 in the init positions and increasing 1 mod 3 on each CW turn.

//

// In case of the four 'free' corners their twist is relative to the position of the 'free'

// tetrahedron. And so, for example the twist of free corner 1 (whose 0th face is orange) is equal

// to 0 if free corner 7 is on the same face like 0th face of corner 1 (which is the case in init

// position); then once free corners 2,4,7 permute CW, twist of corner 1 increases by 1 mod 3.

  public static void computeCornerTwists(int[] twists, int[] quats)

    {

    twists[0] = retFixed(0,quats[0]);

    twists[3] = retFixed(1,quats[3]);

    twists[5] = retFixed(2,quats[5]);

    twists[6] = retFixed(3,quats[6]);

    twists[1] = retFree(0,quats[1]);

    twists[2] = retFree(1,quats[2]);

    twists[4] = retFree(2,quats[4]);

    twists[7] = retFree(3,quats[7]);

    }

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

  private int[] computeCenterPerm(int[] quats)

    {

    int[] output = new int[6];

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

      {

      output[i] = -1;

      int[][] c = centerQuats[i];

      int q = quats[i];

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

        if( c[j][0]==q || c[j][1]==q )

          {

          output[i] = j;

          break;

          }

      }

    return output;

    }

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

  private void fillCenterQuats(int[] quats, int[] perm)

    {

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

      {

      quats[i] = centerQuats[i][perm[i]][0];

      }

    }

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

  private int freeIndex(int taken, int seq)

    {

    return seq + (seq>=taken ? 1:0);

    }

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

  public int[] getQuats(int index)

    {

    int center_perm_num = (index%360);

    index /= 360;

    int totalTwist = (index%2187);

    int locationOfFree0 = (index/2187);

    int[] quats = new int[14];

    int[] center_perm = new int[6];

    int[] twist = new int[8];

    TablebaseHelpers.getEvenPermutationFromNum(center_perm, center_perm_num);

    fillCenterQuats(quats,center_perm);

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

      {

      twist[i] = (totalTwist%3);

      totalTwist /= 3;

      }

    int total = twist[1]+twist[2]+twist[4];

    twist[7] = ((6-total)%3);

    int locationOfFree1 = freeIndex(locationOfFree0,0);

    int locationOfFree2 = freeIndex(locationOfFree0,1);

    int locationOfFree3 = freeIndex(locationOfFree0,2);

    quats[0] = fixedQuats[0][twist[0]];

    quats[3] = fixedQuats[1][twist[3]];

    quats[5] = fixedQuats[2][twist[5]];

    quats[6] = fixedQuats[3][twist[6]];

    quats[1] = freeQuats[0][locationOfFree0][twist[1]];

    quats[2] = freeQuats[1][locationOfFree1][twist[2]];

    quats[4] = freeQuats[2][locationOfFree2][twist[4]];

    quats[7] = freeQuats[3][locationOfFree3][twist[7]];

    return quats;

    }

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

  public int getIndex(int[] quats)

    {

    int[] center_perm = computeCenterPerm(quats);

    int center_perm_num = TablebaseHelpers.computeEvenPermutationNum(center_perm);

    int[] twist = new int[8];

    computeCornerTwists(twist,quats);

    int totalTwist = twist[0]+ 3*(twist[1]+ 3*(twist[2]+ 3*(twist[3]+ 3*(twist[4]+ 3*(twist[5]+ 3*twist[6])))));

    int locationOfFree0 = computeLocation(quats[1]);

    return center_perm_num+ 360*(totalTwist + 2187*locationOfFree0);

    }

}