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

import org.distorted.objectlib.touchcontrol.TouchControlIcosahedron;

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

public class TwistyIcosamate extends ShapeHexahedron

{

  // 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)/2;

  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;

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

  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};

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

      }

    return mCuts;

    }

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

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

    {

    boolean[] tmp = new boolean[] {true,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 )

      {

      mPosition = new float[][]

         {

             { 0, A, 0},

             { 0, B, C},

             { D, B, E},

             { F, B, H},

             {-F, B, H},

             {-D, B, E},

             { D,-B,-E},

             { F,-B,-H},

             {-F,-B,-H},

             {-D,-B,-E},

             { 0,-B,-C},

             { 0,-A, 0},

             {    X1, Y1, Z1   },

             {    X2, Y1, Z2   },

             {     0, Y1, Z3   },

             {   -X2, Y1, Z2   },

             {   -X1, Y1, Z1   },

             {     0,-Y2, Z4   },

             {    X3,-Y2, Z5   },

             {    X4,-Y2, Z6   },

             {   -X4,-Y2, Z6   },

             {   -X3,-Y2, Z5   },

             {     0, Y2,-Z4   },

             {   -X3, Y2,-Z5   },

             {   -X4, Y2,-Z6   },

             {    X4, Y2,-Z6   },

             {    X3, Y2,-Z5   },

             {   -X1,-Y1,-Z1   },

             {   -X2,-Y1,-Z2   },

             {     0,-Y1,-Z3   },

             {    X2,-Y1,-Z2   },

             {    X1,-Y1,-Z1   },

         };

      }

    return mPosition;

    }

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

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

    {

    return mObjectQuats[0];  // TODO

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      float H1 = (B-A)/2;

      return new float[][] { {0,0,0},{0,H1,C/2},{D/2,H1,E/2},{F/2,H1,H/2},{-F/2,H1,H/2},{-D/2,H1,E/2},{0,-A,0} };

      }

    else

      {

      return new float[][] { {F/2,Y2,(C-H)/2-Z4},{0,-B+Y2,-H-Z4},{-F/2,Y2,(C-H)/2-Z4},{0,Y2,-Z4} };

      }

    }

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

  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 2;

    }

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

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

    {

    return cubit<12 ? 0:1;

    }

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

  public float getStickerRadius()

    {

    return 0.09f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.20f : 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()

    {

    return ObjectType.ICOS_2.name();

    }

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

  public ObjectSignature getSignature()

    {

    return new ObjectSignature(ObjectSignatures.ICOS_2);

    }

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

  public String getObjectName()

    {

    return "Icosamate";

    }

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

  public String getInventor()

    {

    return "Jason Smith";

    }

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

  public int getYearOfInvention()

    {

    return 2010;

    }

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

  public int getComplexity()

    {

    return 3;

    }

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

  public String[][] getTutorials()

    {

    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"},

                          };

    }

}