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.objects;

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

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

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.InitAssets;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectSignatures;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.shape.ShapeIcosahedron;

import org.distorted.objectlib.touchcontrol.TouchControlIcosahedron;

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

public class TwistyIcosamate extends ShapeIcosahedron

{

  // topmost vertex (0,A,0) and 3 vertices from the second-topmost-layer, front one and two ones

  // to the right: (0,B,C) , (D,B,E) , (F,B,H)

  private static final float Z = (float)Math.sqrt(5+SQ5);

  private static final float A = Z*(SQ2/4);

  private static final float B = Z*(SQ2*SQ5/20);

  private static final float C = Z*(SQ2*SQ5/10);

  private static final float D = (SQ5+1)/4;

  private static final float E = Z*(SQ5-1)/(4*SQ2*SQ5);

  private static final float F = 0.5f;

  private static final float H =-Z*(SQ5+1)/(4*SQ2*SQ5);

  private static final float X1 = D/3;

  private static final float X2 = (D+F)/3;

  private static final float X3 = (2*D+F)/3;

  private static final float X4 = (D+F)/3;

  private static final float Y1 = (A+2*B)/3;

  private static final float Y2 = B/3;

  private static final float Z1 = (C+E)/3;

  private static final float Z2 = (E+H)/3;

  private static final float Z3 = 2*H/3;

  private static final float Z4 = (C-2*H)/3;

  private static final float Z5 = -H/3;

  private static final float Z6 = (H-C-E)/3;

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(   0,  1,  0),

           new Static3D(   0,B/A,C/A),

           new Static3D( D/A,B/A,E/A),

           new Static3D( F/A,B/A,H/A),

           new Static3D(-F/A,B/A,H/A),

           new Static3D(-D/A,B/A,E/A)

         };

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPosition;

  private int[] mQuatIndex;

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

  public TwistyIcosamate(int meshState, int iconMode, Static4D quat, Static3D move, float scale, InitData data, InitAssets asset)

    {

    super(meshState, iconMode, data.getNumLayers()[0], quat, move, scale, data, asset);

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      int[][] basicAngle = getBasicAngles();

      mEdges = ScrambleEdgeGenerator.getScrambleEdgesSingle(basicAngle);

      }

    return mEdges;

    }

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

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

    {

    if( mCuts==null )

      {

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

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

      }

    return mCuts;

    }

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

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

    {

    int nL = numLayers[0];

    boolean[] tmp = new boolean[nL];

    for(int i=0; i<nL; i++) tmp[i] = true;

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

    }

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

  public int getTouchControlType()

    {

    return TC_ICOSAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

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

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

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

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

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlIcosahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlIcosahedron.FACE_AXIS;

    }

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

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

    {

    if( mPosition==null )

      {

      float N = numLayers[0];

      float AN = N*A;

      float BN = N*B;

      float CN = N*C;

      float DN = N*D;

      float EN = N*E;

      float FN = N*F;

      float HN = N*H;

      mPosition = new float[][]

         {

             {  0, AN,  0},

             {  0, BN, CN},

             { DN, BN, EN},

             { FN, BN, HN},

             {-FN, BN, HN},

             {-DN, BN, EN},

             { DN,-BN,-EN},

             { FN,-BN,-HN},

             {-FN,-BN,-HN},

             {-DN,-BN,-EN},

             {  0,-BN,-CN},

             {  0,-AN,  0},

             {  X1*N, Y1*N, Z1*N   },

             {  X2*N, Y1*N, Z2*N   },

             {     0, Y1*N, Z3*N   },

             { -X2*N, Y1*N, Z2*N   },

             { -X1*N, Y1*N, Z1*N   },

             {     0,-Y2*N, Z4*N   },

             {  X3*N,-Y2*N, Z5*N   },

             {  X4*N,-Y2*N, Z6*N   },

             { -X4*N,-Y2*N, Z6*N   },

             { -X3*N,-Y2*N, Z5*N   },

             {     0, Y2*N,-Z4*N   },

             { -X3*N, Y2*N,-Z5*N   },

             { -X4*N, Y2*N,-Z6*N   },

             {  X4*N, Y2*N,-Z6*N   },

             {  X3*N, Y2*N,-Z5*N   },

             { -X1*N,-Y1*N,-Z1*N   },

             { -X2*N,-Y1*N,-Z2*N   },

             {     0,-Y1*N,-Z3*N   },

             {  X2*N,-Y1*N,-Z2*N   },

             {  X1*N,-Y1*N,-Z1*N   },

         };

      }

    return mPosition;

    }

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

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

    {

    if( mQuatIndex==null )

      {

      mQuatIndex = new int[]

        {

         0,12,5,9,13,8,10,6,7,18,14,55,

         0,4,3,2,1, 6,11,32,14,26, 41,27,7,5,10, 35,18,45,33,15

        };

      }

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      float N = getNumLayers()[0];

      float X = B-A;

      return new float[][] { {0,0,0},{0,X,C},{D,X,E},{F,X,H},{-F,X,H},{-D,X,E},{0,-A*N,0} };

      }

    else

      {

      float N = getNumLayers()[0];

      float CX = X1*N;

      float CY = Y1*N;

      float CZ = Z1*N;

      return new float[][] { { D-CX, A*(N-1)+  B-CY,   E-CZ },

                             { D-CX, A*(N-2)+2*B-CY, C+E-CZ },

                             {  -CX, A*(N-1)+  B-CY, C  -CZ },

                             {  -CX,            -CY,    -CZ }

                           };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int[][] indices =

          {

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

          };

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

      }

    else

      {

      int[][] indices =

          {

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

          };

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

      float h1 = isInIconMode() ? 0.001f : 0.04f;

      float h2 = 0.001f;

      float[][] bands = { {h1,27,0.2f,0.4f,5,0,0}, {h2,27,0.2f,0.4f,3,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

      float h1 = isInIconMode() ? 0.001f : 0.04f;

      float h2 = 0.001f;

      float[][] bands = { {h1,25,0.2f,0.4f,5,0,0}, {h2,25,0.2f,0.4f,3,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

      float[][] corners  = { {0.04f,0.12f},{0.04f,0.10f} };

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

      float[][] centers  = { {0,-A/2,0} };

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

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

      }

    else

      {

      float[][] corners = { {0.04f,0.15f} };

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

      float[][] centers = { {0,Y2/2,-Z4/2} };

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

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return getNumLayers()[0]==2 ? 2 : 3;

    }

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

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

    {

    int N = getNumLayers()[0];

    return cubit<12 ? 0 : (cubit<10*N*(N-1)+12 ? 1 : 2);

    }

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

  public float getStickerRadius()

    {

    return 0.09f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.14f : 0.09f;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][] getBasicAngles()

    {

    if( mBasicAngle==null )

      {

      int num = getNumLayers()[0];

      int[] tmp = new int[num];

      for(int i=0; i<num; i++) tmp[i] = 5;

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

      }

    return mBasicAngle;

    }

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

  public String getShortName()

    {

    switch(getNumLayers()[0])

      {

      case 2: return ObjectType.ICOS_2.name();

      case 3: return ObjectType.ICOS_3.name();

      }

    return null;

    }

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

  public ObjectSignature getSignature()

    {

    switch(getNumLayers()[0])

      {

      case 2: return new ObjectSignature(ObjectSignatures.ICOS_2);

      case 3: return new ObjectSignature(ObjectSignatures.ICOS_3);

      }

    return null;

    }

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

  public String getObjectName()

    {

    switch(getNumLayers()[0])

      {

      case 2: return "Icosamate";

      case 3: return "Master Icosamate";

      }

    return null;

    }

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

  public String getInventor()

    {

    switch(getNumLayers()[0])

      {

      case 2: return "Jason Smith";

      case 3: return "Keisuke Maruyama";

      }

    return null;

    }

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

  public int getYearOfInvention()

    {

    switch(getNumLayers()[0])

      {

      case 2: return 2010;

      case 3: return 2018;

      }

    return 0;

    }

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

  public int getComplexity()

    {

    return getNumLayers()[0]==2 ? 3 : 4;

    }

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

  public String[][] getTutorials()

    {

    int[] numLayers = getNumLayers();

    switch(numLayers[0])

      {

      case 2: return new String[][] {

                            {"gb","e7Es4Zx6Sl4","Icosamate introduction & algorithms","Superantoniovivaldi"},

                            {"gb","ZhkklbYfs98","Icosamate solve","Superantoniovivaldi"},

                            {"pl","eJTLTeoicWI","Icosamate TUTORIAL PL","MrUK"},

                            {"vn","RVjjxj9rPeg","BẠN PHẠM BẢO GIẢI ICOSAMATE","VĂN CÔNG TÙNG"},

                          };

      case 3: return new String[][] {

                            {"gb","77aBjBdfA2Q","Master Icosamate Algorithms","Superantoniovivaldi"},

                            {"gb","j6AIwlIofFU","Master Icosamate Tutorial","Superantoniovivaldi"},

                            {"gb","5Z1B5r6-CxM","Astrominx Tutorial","Jabberwock Technologies"},

                            {"pl","","Icosamate TUTORIAL PL","MrUK"},

                            {"vn","C4YO0B4rgTc","Tutorial N.237- Master Icosamate 1/3","Duy Thích Rubik"},

                            {"vn","90m_0AoyOHU","Tutorial N.237- Master Icosamate 2/3","Duy Thích Rubik"},

                            {"vn","LOd5qBwoP_k","Tutorial N.237- Master Icosamate 3/3","Duy Thích Rubik"},

                          };

      }

    return null;

    }

}