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;

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

public class TBDino4 extends TablebasesAbstract

{

  private static final int INDEX_INVERTED = 90000;  // TODO

  private int[][] mAngles;

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

  public TBDino4()

    {

    super();

    }

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

  public TBDino4(Resources res)

    {

    super(res,0);

    }

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

  int[][] getBasicAngles()

    {

    if( mAngles==null )

      {

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

      mAngles = new int[][] { tmp,tmp,tmp,tmp };

      }

    return mAngles;

    }

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

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

         {

             { 0.0f, 1.5f, 1.5f },

             { 1.5f, 0.0f, 1.5f },

             { 0.0f,-1.5f, 1.5f },

             {-1.5f, 0.0f, 1.5f },

             { 1.5f, 1.5f, 0.0f },

             { 1.5f,-1.5f, 0.0f },

             {-1.5f,-1.5f, 0.0f },

             {-1.5f, 1.5f, 0.0f },

             { 0.0f, 1.5f,-1.5f },

             { 1.5f, 0.0f,-1.5f },

             { 0.0f,-1.5f,-1.5f },

             {-1.5f, 0.0f,-1.5f }

         };

    }

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

  float[][] getCuts()

    {

    float[] cut = new float[] { -SQ3/3, SQ3/3 };

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

    }

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

// exclude the middle layer

  boolean[][] getRotatable()

    {

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

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

    }

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

// specifically for the tablebase

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

// two solved positions: original and mirrored (left face swapped with right)

  @Override

  int[] getSolvedIndices()

    {

    return new int[] {0,INDEX_INVERTED};

    }

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

// ditto

  @Override

  boolean isSolved(int index)

    {

    return index==0 || index==INDEX_INVERTED;

    }

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

// we can never really move the top-front edge, because if we do so, we would also rotate the

// rotation axis themselves! (see getIndex() where the cubit quats are normalized so that quat[0]

// - i.e. the front-top edge - is always 0).

// That's why map the moves (0,2,X) to (0,0&1,-X) and (3,0,X) to (3,1&2,-X)

  @Override

  int[] newMove(int axis, int layer, int angle)

    {

    if( axis==0 && layer==2 ) return new int[] { axis, 3, angle==1 ? 1:-1};

    if( axis==3 && layer==0 ) return new int[] { axis, 6, angle==1 ? 1:-1};

    int maxAngle = mAngles[axis][layer];

    angle = maxAngle-angle;

    if( angle> 0.5f*maxAngle ) angle -= maxAngle;

    return new int[] { axis, (1<<layer), angle };

    }

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

  @Override

  void convertMoves(int[][] moves)

    {

    for(int[] move : moves )

      {

      int[] newMove = newMove(move[0],move[1],move[2]);

      move[0] = newMove[0];

      move[1] = newMove[1];

      move[2] = newMove[2];

      }

    }

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

// 15408 really (see https://www.jaapsch.net/puzzles/dinocube.htm) but we do not assign indices

// tightly but do (11 over 2)*(9 over 3)*(6 over 3) = 92400.

  int getSize()

    {

    return 92400;

    }

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

  int getMinScramble()

    {

    return 5;

    }

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

  public static int indexFromPartition(int[] partition)

    {

    return 0;

    }

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

  private static int[] quatsFromPartition(int[] partition)

    {

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

    }

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

  private static int[] partitionFromQuats(int[] quats)

    {

    return null;

    }

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

  private static int[] partitionFromIndex(int index)

    {

    return null;

    }

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

  int[] getQuats(int index)

    {

    int[] partition = partitionFromIndex(index);

    return quatsFromPartition(partition);

    }

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

  int getIndex(int[] quats)

    {

    int[] partition = partitionFromQuats(quats);

    return indexFromPartition(partition);

    }

}