TwistyPuzzleLib

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

// Copyright 2022 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.objects;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectType;

import java.io.InputStream;

import static org.distorted.objectlib.touchcontrol.TouchControl.TYPE_NOT_SPLIT;

import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.C2;

import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.COS54;

import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.SIN54;

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

public class TwistyPentultimate extends TwistyDodecahedron

{

  private float[][] mCuts;

  private float[][] mPosition;

  private int[] mQuatIndex;

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

  public TwistyPentultimate(InitData data, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(data, meshState, iconMode, quat, move, scale, stream);

    }

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

// all moves in a single state

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      int size=0;

      int[][] basicAngles = getBasicAngles();

      for (int[] basic : basicAngles)

        for (int i : basic) size += (i-1);

      int[] edge = new int[2*size];

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

          {

          edge[2*i  ] = i;

          edge[2*i+1] = 0;

          }

      mEdges = new int[][] { edge };

      }

    return mEdges;

    }

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

  @Override

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  @Override

  public boolean[][] getLayerRotatable(int[] numLayers)

    {

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

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

    }

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

  @Override

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

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

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

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

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

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

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

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

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

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

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

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

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

      };

    }

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

  public float[][] getCubitPositions(int[] numLayers)

    {

    if( mPosition==null )

      {

      if( mCenterCoords==null ) initializeCenterCoords();

      final float A = 2.0f/3;

      mPosition = new float[NUM_CORNERS+NUM_CENTERS][3];

      for(int corner=0; corner<NUM_CORNERS; corner++)

        {

        mPosition[corner][0] = A*mCorners[corner][0];

        mPosition[corner][1] = A*mCorners[corner][1];

        mPosition[corner][2] = A*mCorners[corner][2];

        }

      for(int center=0; center<NUM_CENTERS; center++)

        {

        int index = center+NUM_CORNERS;

        mPosition[index][0] = A*mCenterCoords[center][0];

        mPosition[index][1] = A*mCenterCoords[center][1];

        mPosition[index][2] = A*mCenterCoords[center][2];

        }

      }

    return mPosition;

    }

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

  public Static4D getCubitQuats(int cubit, int[] numLayers)

    {

    if( mQuatIndex==null )

      {

      mQuatIndex = new int[]

        {

         0,29,59,48,18,53,22,49,11,54,10,52,17,27,19,26, 9,28,23,45,

         0, 4, 5, 6,26, 3, 2, 7,16,13, 1,19

        };

      }

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    final float A = 2.0f/3;

    if( variant==0 )

      {

      float x0  = A*mCorners[ 0][0];

      float x2  = A*mCorners[ 2][0];

      float x12 = A*mCorners[12][0];

      float x16 = A*mCorners[16][0];

      float y0  = A*mCorners[ 0][1];

      float y2  = A*mCorners[ 2][1];

      float y12 = A*mCorners[12][1];

      float y16 = A*mCorners[16][1];

      float z0  = A*mCorners[ 0][2];

      float z2  = A*mCorners[ 2][2];

      float z12 = A*mCorners[12][2];

      float z16 = A*mCorners[16][2];

      return new float[][]

        {

            { 0,0,0 },

            { (x16-x0)/2, (y16-y0)/2, (z16-z0)/2, },

            { (x12-x0)/2, (y12-y0)/2, (z12-z0)/2, },

            { (x2 -x0)/2, (y2 -y0)/2, (z2 -z0)/2, },

            { 0,-1,-2*C2 },

        };

      }

    else

      {

      int i0 = mCenterMap[0][0];

      int i1 = mCenterMap[0][1];

      int i2 = mCenterMap[0][2];

      int i3 = mCenterMap[0][3];

      int i4 = mCenterMap[0][4];

      float x0 = A*mCorners[i0][0];

      float x1 = A*mCorners[i1][0];

      float x2 = A*mCorners[i2][0];

      float x3 = A*mCorners[i3][0];

      float x4 = A*mCorners[i4][0];

      float y0 = A*mCorners[i0][1];

      float y1 = A*mCorners[i1][1];

      float y2 = A*mCorners[i2][1];

      float y3 = A*mCorners[i3][1];

      float y4 = A*mCorners[i4][1];

      float z0 = A*mCorners[i0][2];

      float z1 = A*mCorners[i1][2];

      float z2 = A*mCorners[i2][2];

      float z3 = A*mCorners[i3][2];

      float z4 = A*mCorners[i4][2];

      float cx = A*mCenterCoords[0][0];

      float cy = A*mCenterCoords[0][1];

      float cz = A*mCenterCoords[0][2];

      float X0 = (x0+x1)/2 -cx;

      float Y0 = (y0+y1)/2 -cy;

      float Z0 = (z0+z1)/2 -cz;

      float X1 = (x1+x2)/2 -cx;

      float Y1 = (y1+y2)/2 -cy;

      float Z1 = (z1+z2)/2 -cz;

      float X2 = (x2+x3)/2 -cx;

      float Y2 = (y2+y3)/2 -cy;

      float Z2 = (z2+z3)/2 -cz;

      float X3 = (x3+x4)/2 -cx;

      float Y3 = (y3+y4)/2 -cy;

      float Z3 = (z3+z4)/2 -cz;

      float X4 = (x4+x0)/2 -cx;

      float Y4 = (y4+y0)/2 -cy;

      float Z4 = (z4+z0)/2 -cz;

      float X5 = -cx;

      float Y5 = -cy;

      float Z5 = -cz;

      return new float[][]

         {

             { X0,Y0,Z0 },

             { X1,Y1,Z1 },

             { X2,Y2,Z2 },

             { X3,Y3,Z3 },

             { X4,Y4,Z4 },

             { X5,Y5,Z5 }

         };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 ) // corner

      {

      int[][] indices =

        {

            {0,1,3},

            {0,3,2},

            {0,2,1},

            {4,3,1},

            {4,2,3},

            {4,1,2}

        };

      return new ObjectShape(getVertices(variant), indices);

      }

    else

      {

      int[][] indices =

         {

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

             {0,5,1},

             {1,5,2},

             {2,5,3},

             {3,5,4},

             {4,5,0}

         };

      return new ObjectShape(getVertices(variant), indices);

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

      float H = isInIconMode() ? 0.001f : 0.03f;

      float[][] bands = { {H,10,0.5f,0.2f,4,0,0}, {0.001f, 1,0.5f,0.2f,3,0,0} };

      int[] indices   = { 0,0,0,1,1,1 };

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

      float H = isInIconMode() ? 0.001f : 0.03f;

      float[][] bands = { {H,15,0.5f,0.2f,6,0,0}, {0.001f, 1,0.5f,0.2f,3,0,0} };

      int[] indices   = { 0,1,1,1,1,1 };

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

      float A = (2*SQ3/3)*SIN54;

      float B = 0.4f;

      float[][] corners = { { 0.025f, 0.20f } };

      int[] indices     = { 0,0,0,-1,-1,-1 };

      float[][] centers = { {0.0f, -(float)Math.sqrt(1-A*A)*B,-A*B} };

      return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);

      }

    else

      {

      final double ANGLE = 0.825f*Math.PI;

      final float cosA  = (float)Math.cos(ANGLE);

      final float sinA  = (float)Math.sin(ANGLE);

      float TAN54 = SIN54/COS54;

      float R  = 1.5f*(TAN54-(1/TAN54));

      float[][] corners = { { 0.025f, 0.20f } };

      int[] indices     = { 0,0,0,0,0,-1 };

      float[][] centers = { { 0.0f,R*cosA,-R*sinA } };

      return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 2;

    }

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

  public int getCubitVariant(int cubit, int[] numLayers)

    {

    return cubit<NUM_CORNERS ? 0:1;

    }

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

  public float[][] getCuts(int[] numLayers)

    {

    if( mCuts==null )

      {

      float[] cut = new float[] { 0 };

      mCuts = new float[][] { cut,cut,cut,cut,cut,cut };

      }

    return mCuts;

    }

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

  public float getStickerRadius()

    {

    return 0.15f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.20f : 0.13f;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public String getShortName()

    {

    return ObjectType.PENT_2.name();

    }

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

  public ObjectSignature getSignature()

    {

    return new ObjectSignature(ObjectType.PENT_2);

    }

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

  public String getObjectName()

    {

    return "Pentultimate";

    }

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

  public String getInventor()

    {

    return "Jason Smith";

    }

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

  public int getYearOfInvention()

    {

    return 2008;

    }

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

  public int getComplexity()

    {

    return 3;

    }

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

  public String[][] getTutorials()

    {

    return new String[][]{

                          {"gb","raeskk-whbU","Pentultimate classification and solve","SuperAntoniovivaldi"},

                          {"gb","QamIeNJBB1M","How to solve a Pentultimate","bmenrigh"},

                         };

    }

}