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 static org.distorted.objectlib.touchcontrol.TouchControlIcosahedron.*;

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.metadata.Metadata;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.metadata.ListObjects;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.shape.ShapeIcosahedron;

import org.distorted.objectlib.touchcontrol.TouchControlIcosahedron;

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

public class TwistyIcosamate extends ShapeIcosahedron

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(                   0,                   1,                   0),

           new Static3D(                   0, VEC[1][1]/VEC[0][1], VEC[1][2]/VEC[0][1]),

           new Static3D( VEC[2][0]/VEC[0][1], VEC[1][1]/VEC[0][1], VEC[2][2]/VEC[0][1]),

           new Static3D( VEC[3][0]/VEC[0][1], VEC[1][1]/VEC[0][1], VEC[3][2]/VEC[0][1]),

           new Static3D(-VEC[3][0]/VEC[0][1], VEC[1][1]/VEC[0][1], VEC[3][2]/VEC[0][1]),

           new Static3D(-VEC[2][0]/VEC[0][1], VEC[1][1]/VEC[0][1], VEC[2][2]/VEC[0][1])

         };

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPosition;

  private int[] mQuatIndex;

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

  public TwistyIcosamate(int iconMode, Static4D quat, Static3D move, float scale, Metadata meta, InitAssets asset)

    {

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

    }

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

  @Override

  public int getInternalColor()

    {

    return 0xff222222;

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      int[][] basicAngle = getBasicAngles();

      mEdges = ScrambleEdgeGenerator.getScrambleEdgesSingle(basicAngle);

      }

    return mEdges;

    }

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

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

    {

    if( mCuts==null )

      {

      int nL = numLayers[0];

      float[] cut = new float[nL-1];

      for(int i=0; i<nL-1; i++) cut[i] = VEC[1][1]*(2*i+2-nL);

      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;

    }

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

  private float[] computeOff(int index, int N)

    {

    if( N==2 )

      {

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

      }

    else

      {

      switch(index)

        {

        case 0 : return new float[] {0,SQ3/9,0};

        case 1 : return new float[] {-1.0f/6,-SQ3/18,0};

        default: return new float[] { 1.0f/6,-SQ3/18,0};

        }

      }

    }

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

// Rodrigues

  private void rotateVect(float vx, float vy, float vz, float sin, float cos, float[] vec)

    {

    float cx = vy*vec[2] - vz*vec[1];

    float cy = vz*vec[0] - vx*vec[2];

    float cz = vx*vec[1] - vy*vec[0];

    float scalar = vx*vec[0] + vy*vec[1] + vz*vec[2];

    vec[0] = vec[0]*cos + cx*sin + vx*scalar*(1-cos);

    vec[1] = vec[1]*cos + cy*sin + vy*scalar*(1-cos);

    vec[2] = vec[2]*cos + cz*sin + vz*scalar*(1-cos);

    }

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

  private void rotateFacePosition(float x, float y, float z, float[] off)

    {

    float cosB = (float)Math.sqrt(x*x+z*z);

    float sinB = y;

    float sinA = x/cosB;

    float cosA = z/cosB;

    float vec1X = 0;

    float vec1Y = 1;

    float vec1Z = 0;

    float vec2X = -z/cosB;

    float vec2Y = 0;

    float vec2Z = x/cosB;

    rotateVect(vec1X,vec1Y,vec1Z,sinA,cosA,off);

    rotateVect(vec2X,vec2Y,vec2Z,sinB,cosB,off);

    }

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

  private float[] createFacePosition(float vx, float vy, float vz, float scale, boolean inverted, float[] off)

    {

    float[] tmp = new float[3];

    tmp[0] = off[0];

    tmp[1] = off[1];

    tmp[2] = off[2];

    rotateFacePosition(vx,vy,vz,tmp);

    if( inverted )

      {

      tmp[0] = -tmp[0];

      tmp[1] = -tmp[1];

      tmp[2] = -tmp[2];

      }

    float[] ret = new float[3];

    ret[0] = scale*(vx+tmp[0]);

    ret[1] = scale*(vy+tmp[1]);

    ret[2] = scale*(vz+tmp[2]);

    return ret;

    }

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

  private float[] createEdgePosition(int edge, int index, int N)

    {

    int[] edgeIndices = EDGE_INDICES[edge];

    int i0 = edgeIndices[0];

    int i1 = edgeIndices[1];

    float x = N*(VEC[i0][0]+VEC[i1][0])/2;

    float y = N*(VEC[i0][1]+VEC[i1][1])/2;

    float z = N*(VEC[i0][2]+VEC[i1][2])/2;

    return new float[] { x,y,z };

    }

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

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

    {

    if( mPosition==null )

      {

      int N = numLayers[0];

      int numV = 12;

      int perF = N*(N-1)/2;

      int numF = 20*perF;

      int perE = N-2;

      int numE = 30*perE;

      mPosition = new float[numV+numF+numE][];

      for(int v=0; v<12; v++)

        mPosition[v] = new float[] { VEC[v][0]*N, VEC[v][1]*N, VEC[v][2]*N };

      float[][] off = new float[perF][];

      for(int i=0; i<perF; i++) off[i] = computeOff(i,N);

      for(int f=0; f<20; f++)

        {

        Static3D vect = TouchControlIcosahedron.FACE_AXIS[f];

        float x = vect.get0();

        float y = vect.get1();

        float z = vect.get2();

        boolean inverted = f>=10;

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

          mPosition[12+f*perF+i] = createFacePosition(x,y,z,DIST3D*N,inverted,off[i]);

        }

      for(int e=0; e<30; e++)

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

          mPosition[12+20*perF+e*perE+i] = createEdgePosition(e,i,N);

      }

    return mPosition;

    }

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

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

    {

    if( mQuatIndex==null )

      {

      switch( numLayers[0] )

        {

        case 2: mQuatIndex = new int[]

                  {

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

                  0,4,3,2,1,

                  6,11,32,14,26,

                  41,27,7,5,10,

                  35,18,45,33,15

                  };

                break;

        case 3: mQuatIndex = new int[]

                  {

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

                  0,52,28,4,44,9,3,31,24,2,13,51,1,8,42,

                  21,30,6,16,11,49,54,32,39,48,14,23,37,43,26,

                  41,50,46,27,40,34,7,25,17,29,5,12,10,20,53,

                  56,38,35,58,22,18,57,47,45,55,36,33,59,19,15,

                  0,4,3,2,1,

                  5,20,31,13,8,

                  6,16,49,10,39,41,23,27,17,7,

                  14,22,30,11,19,

                  35,18,45,33,15

                  };

                break;

        }

      }

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    float N = getNumLayers()[0];

    if( variant==0 )

      {

      float[] pos = mPosition[0];

      float[][] ret = new float[7][];

      for(int i=0; i<6; i++) ret[i] = new float[] { VEC[i][0]-pos[0], VEC[i][1]+(N-1)*VEC[0][1]-pos[1], VEC[i][2]-pos[2] };

      ret[6] = new float[] { -pos[0], -pos[1], -pos[2] };

      return ret;

      }

    else if( variant==1 )

      {

      float CX = mPosition[12][0];

      float CY = mPosition[12][1];

      float CZ = mPosition[12][2];

      float v1x = VEC[0][0]*(N-1)+VEC[2][0]; float v1y = VEC[0][1]*(N-1)+          VEC[2][1]; float v1z = VEC[0][2]*(N-1)+VEC[2][2];

      float v2x = VEC[2][0];                 float v2y = VEC[0][1]*(N-2)+VEC[1][1]+VEC[2][1]; float v2z = VEC[1][2]+VEC[2][2];

      float v3x = VEC[0][0]*(N-1)+VEC[1][0]; float v3y = VEC[0][1]*(N-1)+VEC[1][1]          ; float v3z = VEC[0][2]*(N-1)+VEC[1][2];

      return new float[][] { { v1x-CX, v1y-CY, v1z-CZ },

                             { v2x-CX, v2y-CY, v2z-CZ },

                             { v3x-CX, v3y-CY, v3z-CZ },

                             {    -CX,    -CY,    -CZ }

                           };

      }

    else

      {

      float[] pos = mPosition[72];

      float v1x = N*(VEC[0][0] + VEC[0][0] + VEC[1][0])/3; float v1y = N*(VEC[0][1] + VEC[0][1] + VEC[1][1])/3; float v1z = N*(VEC[0][2] + VEC[0][2] + VEC[1][2])/3;

      float v2x = N*(VEC[0][0] + VEC[1][0] + VEC[1][0])/3; float v2y = N*(VEC[0][1] + VEC[1][1] + VEC[1][1])/3; float v2z = N*(VEC[0][2] + VEC[1][2] + VEC[1][2])/3;

      float v3x = N*(VEC[0][0] + VEC[1][0] + VEC[2][0])/3; float v3y = N*(VEC[0][1] + VEC[1][1] + VEC[2][1])/3; float v3z = N*(VEC[0][2] + VEC[1][2] + VEC[2][2])/3;

      float v4x =-N*(VEC[0][0] + VEC[1][0] + VEC[2][0])/3; float v4y = N*(VEC[0][1] + VEC[1][1] + VEC[2][1])/3; float v4z = N*(VEC[0][2] + VEC[1][2] + VEC[2][2])/3;

      return new float[][] { { v1x-pos[0], v1y-pos[1], v1z-pos[2] },

                             { v2x-pos[0], v2y-pos[1], v2z-pos[2] },

                             { v3x-pos[0], v3y-pos[1], v3z-pos[2] },

                             { v4x-pos[0], v4y-pos[1], v4z-pos[2] },

                             {    -pos[0],    -pos[1],    -pos[2] }

                           };

      }

    }

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

  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 if( variant==1 )

      {

      int[][] indices =

          {

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

          };

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

      }

    else

      {

      int[][] indices =

          {

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

          };

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    float N = getNumLayers()[0];

    int angle = 25;

    float R = 0.7f;

    float S = 0.5f;

    if( variant==0 )

      {

      int N1 = N==2 ? 5:4;

      int N2 = N==2 ? 3:2;

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

      float h2 = 0.001f;

      float[][] bands = { {h1,angle,R,S,N1,0,0}, {h2,angle,R,S,N2,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else if( variant==1 )

      {

      int N1 = N==2 ? 5:4;

      int N2 = N==2 ? 3:2;

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

      float h2 = 0.001f;

      float[][] bands = { {h1,angle,R,S,N1,0,0}, {h2,angle,R,S,N2,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

      int N1 = N==2 ? 5:4;

      int N2 = N==2 ? 3:2;

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

      float h2 = 0.001f;

      float[][] bands = { {h1,angle,R,S,N1,0,0}, {h2,angle,R,S,N2,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

      float[] pos = mPosition[0];

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

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

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

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

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

      }

    else if( variant==1 )

      {

      float[] pos = mPosition[12];

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

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

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

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

      }

    else

      {

      float[] pos = mPosition[72];

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

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

      float[][] centers = { { -pos[0]/2, -pos[1]/2, -pos[2]/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 ListObjects.ICOS_2.name();

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

      }

    return null;

    }

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

  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;

    }

}