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 android.content.res.Resources;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.objects.TwistyIvy;

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

public class TablebasesIvyCube extends TablebasesAbstract

{

  private static final int[] mTmp = new int[6];

  private static final int[][] MAP = { {0,4,2,2,5,3,4,5,3,0,1,1},

                                       {1,5,3,3,4,2,5,4,2,1,0,0},

                                       {2,0,4,5,0,5,1,1,4,3,3,2},

                                       {3,1,5,4,1,4,0,0,5,2,2,3},

                                       {4,2,0,1,3,0,3,2,1,5,4,5},

                                       {5,3,1,0,2,1,2,3,0,4,5,4} };

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

  public TablebasesIvyCube()

    {

    super();

    }

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

  public TablebasesIvyCube(Resources res)

    {

    super(res,org.distorted.objectlib.R.raw.ivy_2_tablebase);

    }

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

  int[][] getBasicAngles()

    {

    int[] tmp = {3,3};

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

    }

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

  Static3D[] getRotationAxis()

    {

    return TwistyIvy.ROT_AXIS;

    }

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

  float[][] getPosition()

    {

    final float DIST_CORNER = 1;

    final float DIST_CENTER = 1;

    return new float[][]

      {

        { DIST_CORNER, DIST_CORNER, DIST_CORNER },

        {-DIST_CORNER, DIST_CORNER,-DIST_CORNER },

        {-DIST_CORNER,-DIST_CORNER, DIST_CORNER },

        { DIST_CORNER,-DIST_CORNER,-DIST_CORNER },

        { DIST_CENTER,           0,           0 },

        {-DIST_CENTER,           0,           0 },

        {           0, DIST_CENTER,           0 },

        {           0,-DIST_CENTER,           0 },

        {           0,           0, DIST_CENTER },

        {           0,           0,-DIST_CENTER },

      };

    }

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

  float[][] getCuts()

    {

    float[] cut = { 0.0f };

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

    }

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

  boolean[][] getRotatable()

    {

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

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

    return new boolean[][] { tmp1,tmp2,tmp2,tmp1 };

    }

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

// specifically for the tablebase

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

// orientations of 4 corners + any even permutation of 6 centers

  int getSize()

    {

    return (3*3*3*3)*(6*5*4*3);

    }

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

  private int findFirst(int[] table, int value)

    {

    int len = table.length;

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

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

    return -1;

    }

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

  public int[] getQuats(int index)

    {

    int perm_num = index%360;

    index /= 360;

    int twist0 = index%3;

    index /= 3;

    int twist1 = index%3;

    index /= 3;

    int twist2 = index%3;

    index /= 3;

    int twist3 = index%3;

    int[] ret = new int[10];

    ret[0] = twist0==0 ? 0 : (twist0==1 ? 2:1);

    ret[1] = twist1==0 ? 0 : (twist1==1 ? 5:6);

    ret[2] = twist2==0 ? 0 : (twist2==1 ? 3:4);

    ret[3] = twist3==0 ? 0 : (twist3==1 ? 8:7);

    TablebaseHelpers.getEvenPermutationFromNum(mTmp,6,perm_num);

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

      {

      int cubitThatMoves = mTmp[i];

      ret[cubitThatMoves+4] = findFirst(MAP[cubitThatMoves],i);

      }

    return ret;

    }

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

  public int getIndex(int[] quats)

    {

    int twist0 = quats[0]==0 ? 0 : (quats[0]==1 ? 2:1);

    int twist1 = quats[1]==0 ? 0 : (quats[1]==6 ? 2:1);

    int twist2 = quats[2]==0 ? 0 : (quats[2]==4 ? 2:1);

    int twist3 = quats[3]==0 ? 0 : (quats[3]==7 ? 2:1);

    int c4 = MAP[0][quats[4]];

    int c5 = MAP[1][quats[5]];

    int c6 = MAP[2][quats[6]];

    int c7 = MAP[3][quats[7]];

    int c8 = MAP[4][quats[8]];

    int c9 = MAP[5][quats[9]];

    mTmp[c4]=0;

    mTmp[c5]=1;

    mTmp[c6]=2;

    mTmp[c7]=3;

    mTmp[c8]=4;

    mTmp[c9]=5;

    int perm_num = TablebaseHelpers.computeEvenPermutationNum(mTmp);

    return perm_num + 360*(twist0+ 3*(twist1+ 3*(twist2+ 3*twist3)));

    }

}