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

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

import org.distorted.library.helpers.QuatHelper;

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

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

public class TwistyCoinHexahedron extends ShapeHexahedron

{

  static final Static3D[] ROT_AXIS = 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),

           new Static3D(     1,     0,     0),

           new Static3D(     0,     1,     0),

           new Static3D(     0,     0,     1),

         };

  private static final int N = 5;

  private static final float C = 0.2f;

  private static final float D = 0.85f;

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPosition;

  private int[] mQuatIndex;

  private boolean[][] mRotatable;

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

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

    {

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

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      mEdges = new int[][]

        {

          {0,1,1,1, 2,2,3,2, 4,3,5,3, 6,4,7,4, 8,5,9,5, 10,6,11,6, 12,7,13,7, 14,8,15,8},

          {16, 9,17, 9,18, 9, 22,11,23,11,24,11, 28,13,29,13,30,13},

          {19,10,20,10,21,10, 25,12,26,12,27,12, 31,14,32,14,33,14},

          {16, 9,17, 9,18, 9, 22,11,23,11,24,11, 31,14,32,14,33,14},

          {19,10,20,10,21,10, 25,12,26,12,27,12, 28,13,29,13,30,13},

          {16, 9,17, 9,18, 9, 25,12,26,12,27,12, 28,13,29,13,30,13},

          {19,10,20,10,21,10, 22,11,23,11,24,11, 31,14,32,14,33,14},

          {16, 9,17, 9,18, 9, 25,12,26,12,27,12, 31,14,32,14,33,14},

          {19,10,20,10,21,10, 22,11,23,11,24,11, 28,13,29,13,30,13},

          { 0, 1, 1, 1,  4, 3, 5, 3,   8, 5, 9, 5,  12, 7,13, 7},

          { 2, 2, 3, 2,  6, 4, 7, 4,  10, 6,11, 6,  14, 8,15, 8},

          { 0, 1, 1, 1,  4, 3, 5, 3,  10, 6,11, 6,  14, 8,15, 8},

          { 2, 2, 3, 2,  6, 4, 7, 4,   8, 5, 9, 5,  12, 7,13, 7},

          { 0, 1, 1, 1,  6, 4, 7, 4,   8, 5, 9, 5,  14, 8,15, 8},

          { 2, 2, 3, 2,  4, 3, 5, 3,  10, 6,11, 6,  12, 7,13, 7}

        };

      }

    return mEdges;

    }

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

  @Override

  protected float[][][] getStickerStrokes()

    {

    boolean icon = isInIconMode();

    float S1 = icon ? 0.21f : 0.12f;

    float S2 = icon ? 0.21f : 0.07f;

    float S3 = icon ? 0.21f : 0.12f;

    return new float[][][] { {{ S1,S1,S1,S1,S1 }} , {{S2,S2,S2,S2}} , {{S3,S3}} };

    }

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

  @Override

  protected float[][][] getStickerRadii()

    {

    float R = 0.15f;

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

    }

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

  @Override

  public int[][] getScrambleAlgorithms()

    {

    setUpRotatable();

    return ScrambleEdgeGenerator.getScramblingAlgorithms(mBasicAngle, mRotatable);

    }

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

  @Override

  public float[][] returnRotationFactor()

    {

    float C1 = 2.5f;

    float C2 = 1.0f;

    float[] f1 = new float[] { C1,C1,C1 };

    float[] f2 = new float[] { C2,C2,C2 };

    return new float[][] { f1,f1,f1,f1, f2,f2,f2 };

    }

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

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

    {

    if( mCuts==null )

      {

      float C1 = 0.75f*SQ3;

      float C2 = 1.49f;

      float[] cut1 = new float[] { -C1,C1 };

      float[] cut2 = new float[] { -C2,C2 };

      mCuts = new float[][] { cut1,cut1,cut1,cut1,cut2,cut2,cut2 };

      }

    return mCuts;

    }

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

  private void setUpRotatable()

    {

    if( mRotatable==null )

      {

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

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

      }

    }

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

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

    {

    setUpRotatable();

    return mRotatable;

    }

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

  public int getTouchControlType()

    {

    return TC_HEXAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_SPLIT_EDGE_COIN;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

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

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

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

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

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

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

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlHexahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

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

    {

    if( mPosition==null )

      {

      final float A = 1.48f-C;

      final float B = 1.52f;

      final float Z = 1.50f;

      final float E = 0.75f*D;

      mPosition = new float[][]

         {

             { A, A, A},

             { A, A,-A},

             { A,-A, A},

             { A,-A,-A},

             {-A, A, A},

             {-A, A,-A},

             {-A,-A, A},

             {-A,-A,-A},

             { 0, 0, B },

             { 0, 0,-B },

             { 0, B, 0 },

             { 0,-B, 0 },

             { B, 0, 0 },

             {-B, 0, 0 },

             { E, E, Z},

             { E,-E, Z},

             {-E, E, Z},

             {-E,-E, Z},

             { E, E,-Z},

             { E,-E,-Z},

             {-E, E,-Z},

             {-E,-E,-Z},

             { E, Z, E},

             { E, Z,-E},

             {-E, Z, E},

             {-E, Z,-E},

             { E,-Z, E},

             { E,-Z,-E},

             {-E,-Z, E},

             {-E,-Z,-E},

             { Z, E, E},

             { Z, E,-E},

             { Z,-E, E},

             { Z,-E,-E},

             {-Z, E, E},

             {-Z, E,-E},

             {-Z,-E, E},

             {-Z,-E,-E},

         };

      }

    return mPosition;

    }

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

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

    {

    if( mQuatIndex==null ) mQuatIndex = new int[] {0,9,11,4,12,3,6,21,

                                                   0,10,1,4,2,3,

                                                   0,15,17,16,19,10,13,23,1,9,20,7, 11,4,6,21,2,14,18,5,12,3,8,22 };

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[] rotateVertices(float angle, float[] vector, float[] center, float[] rotAxis)

    {

    float[] ret = new float[4];

    float sin = (float)Math.sin(angle/2);

    float cos = (float)Math.cos(angle/2);

    float[] quat= new float[] { sin*rotAxis[0], sin*rotAxis[1], sin*rotAxis[2], cos};

    QuatHelper.rotateVectorByQuat(ret,vector,quat);

    ret[0] += center[0];

    ret[1] += center[1];

    ret[2] += center[2];

    return ret;

    }

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

  private float[][] produceCorner()

    {

    final float angle = (float)Math.PI/(2*N);

    final float A = 0.3f;

    final int N1 = 4;

    final int N2 = N1 + N + 1;

    final int N3 = N2 + N + 1;

    float[][] vertices= new float[3*N+8][3];

    vertices[3*N+7][0] = -A;

    vertices[3*N+7][1] = -A;

    vertices[3*N+7][2] = -A;

    vertices[0][0] = 0;

    vertices[0][1] = 0;

    vertices[0][2] = 0;

    vertices[1][0] =-2;

    vertices[1][1] = 0;

    vertices[1][2] = 0;

    vertices[2][0] = 0;

    vertices[2][1] =-2;

    vertices[2][2] = 0;

    vertices[3][0] = 0;

    vertices[3][1] = 0;

    vertices[3][2] =-2;

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

      {

      float cos1 = (float)Math.cos((N-i)*angle);

      float sin1 = (float)Math.sin((N-i)*angle);

      float cos2 = (float)Math.cos((  i)*angle);

      float sin2 = (float)Math.sin((  i)*angle);

      vertices[N1+i][0] = 2*D*cos1-2;

      vertices[N1+i][1] = 2*D*sin1-2;

      vertices[N1+i][2] = 0;

      vertices[N2+i][0] = 0;

      vertices[N2+i][1] = 2*D*sin2-2;

      vertices[N2+i][2] = 2*D*cos2-2;

      vertices[N3+i][0] = 2*D*cos2-2;

      vertices[N3+i][1] = 0;

      vertices[N3+i][2] = 2*D*sin2-2;

      }

    for(int i=0; i<3*N+8; i++)

      {

      vertices[i][0] = 0.75f*vertices[i][0] + C;

      vertices[i][1] = 0.75f*vertices[i][1] + C;

      vertices[i][2] = 0.75f*vertices[i][2] + C;

      }

    return vertices;

    }

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

  private float[][] produceCenter()

    {

    float[][] ret = new float[4*N+1][];

    float[] rot = new float[] { 0,0,-1 };

    float[] center1 = { 1.5f*D, 1.5f*D, 0  };

    float[] center2 = { 1.5f*D,-1.5f*D, 0  };

    float[] center3 = {-1.5f*D,-1.5f*D, 0  };

    float[] center4 = {-1.5f*D, 1.5f*D, 0  };

    float[] vect1 = { -1.5f*D,0,0,0 };

    float[] vect2 = { 0, 1.5f*D,0,0 };

    float[] vect3 = {  1.5f*D,0,0,0 };

    float[] vect4 = { 0,-1.5f*D,0,0 };

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

      {

      float angle = (float)(Math.PI/2)*i/N;

      ret[i    ] = rotateVertices(angle, vect1, center1, rot);

      ret[i+  N] = rotateVertices(angle, vect2, center2, rot);

      ret[i+2*N] = rotateVertices(angle, vect3, center3, rot);

      ret[i+3*N] = rotateVertices(angle, vect4, center4, rot);

      }

    ret[4*N] = new float[] { 0, 0, -1.5f };

    return ret;

    }

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

  private float[][] produceLeaf()

    {

    float[][] ret = new float[2*N+1][];

    float[] rot = new float[] { 0,0,1 };

    float[] center1 = {-0.75f*D,-0.75f*D, 0 };

    float[] center2 = { 0.75f*D, 0.75f*D, 0 };

    float[] vect1 = {  0, 1.5f*D, 0, 0 };

    float[] vect2 = {  0,-1.5f*D, 0, 0 };

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

      {

      float angle = (float)(Math.PI/2)*i/N;

      ret[  N-1-i] = rotateVertices(angle, vect1, center1, rot);

      ret[2*N-1-i] = rotateVertices(angle, vect2, center2, rot);

      }

    ret[2*N] = new float[] { 0, 0, -1.5f/10 };

    return ret;

    }

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

  private float[][] getVertices(int variant)

    {

         if( variant==0 ) return produceCorner();

    else if( variant==1 ) return produceCenter();

    else                  return produceLeaf();

    }

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

  private int[][] produceCornerShape()

    {

    int[][] indices = new int[3*N+9][];

    indices[0] = new int[N+4];

    indices[1] = new int[N+4];

    indices[2] = new int[N+4];

    indices[0][0] = 2;

    indices[0][1] = 0;

    indices[0][2] = 1;

    indices[1][0] = 3;

    indices[1][1] = 0;

    indices[1][2] = 2;

    indices[2][0] = 1;

    indices[2][1] = 0;

    indices[2][2] = 3;

    int N1 = 4;

    int N2 = N1 + N + 1;

    int N3 = N2 + N + 1;

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

      {

      indices[0][i+3] = N1 + i;

      indices[1][i+3] = N2 + i;

      indices[2][i+3] = N3 + i;

      }

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

      {

      indices[3*i+3] = new int[] { N1+i+1, N1+i, 3*N+7 };

      indices[3*i+4] = new int[] { N2+i+1, N2+i, 3*N+7 };

      indices[3*i+5] = new int[] { N3+i+1, N3+i, 3*N+7 };

      }

    indices[3*N+3] = new int[] { 2    , 4+  N, 3*N+7 };

    indices[3*N+4] = new int[] { 5  +N, 2    , 3*N+7 };

    indices[3*N+5] = new int[] { 5+2*N, 3    , 3*N+7 };

    indices[3*N+6] = new int[] { 3    , 6+2*N, 3*N+7 };

    indices[3*N+7] = new int[] { 1    , 6+3*N, 3*N+7 };

    indices[3*N+8] = new int[] { 4    , 1    , 3*N+7 };

    return indices;

    }

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

  private int[][] produceCenterShape()

    {

    int[][] ret = new int[1+4*N][];

    ret[0] = new int[4*N];

    for(int i=0; i<4*N; i++) ret[0][i] = 4*N-1-i;

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

      {

      ret[i+1] = new int[3];

      ret[i+1][0] = i;

      ret[i+1][1] = i+1;

      ret[i+1][2] = 4*N;

      ret[N+i+1] = new int[3];

      ret[N+i+1][0] = N+i;

      ret[N+i+1][1] = N+i+1;

      ret[N+i+1][2] = 4*N;

      ret[2*N+i+1] = new int[3];

      ret[2*N+i+1][0] = 2*N+i;

      ret[2*N+i+1][1] = 2*N+i+1;

      ret[2*N+i+1][2] = 4*N;

      ret[3*N+i+1] = new int[3];

      ret[3*N+i+1][0] = 3*N+i;

      ret[3*N+i+1][1] = i<N-1 ? 3*N+i+1 : 0;

      ret[3*N+i+1][2] = 4*N;

      }

    return ret;

    }

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

  private int[][] produceLeafShape()

    {

    int[][] ret = new int[2*N+1][];

    ret[0] = new int[2*N];

    for(int i=0; i<2*N; i++) ret[0][i] = i;

    for(int i=1; i<=N-1; i++)

      {

      ret[i] = new int[3];

      ret[i][0] = i;

      ret[i][1] = i-1;

      ret[i][2] = 2*N;

      ret[N-1+i] = new int[3];

      ret[N-1+i][0] = N+i;

      ret[N-1+i][1] = N+i-1;

      ret[N-1+i][2] = 2*N;

      }

    ret[2*N-1] = new int[] { N,  N-1, 2*N };

    ret[2*N  ] = new int[] { 0,2*N-1, 2*N };

    return ret;

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int[][] indices = produceCornerShape();

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

      }

    else if( variant==1 )

      {

      int[][] indices = produceCenterShape();

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

      }

    else

      {

      int[][] indices = produceLeafShape();

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

      float h1 = isInIconMode() ? 0.0001f : 0.03f;

      float h2 = isInIconMode() ? 0.0001f : 0.01f;

      float[][] bands = { {h1,35,0.2f,0.4f,5,2,1}, {h2,35,0.2f,0.4f,2,0,0} };

      int num = 3*N+9;

      int[] indices = new int[num];

      for(int i=3; i<num; i++) indices[i] = 1;

      float S = 1-SQ2/2 - C;

      float[] convexCenter = {-S,-S,-S };

      return new ObjectFaceShape(bands,indices,convexCenter);

      }

    else if( variant==1 )

      {

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

      float h2 = 0.0001f;

      float[][] bands = { {h1,5,0.2f,0.4f,5,0,0}, {h2,5,0.05f,0.1f,2,0,0} };

      int num = 1+4*N;

      int[] indices   = new int[num];

      for(int i=1; i<num; i++) indices[i] = 1;

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

      float h1 = isInIconMode() ? 0.0001f : 0.015f;

      float h2 = isInIconMode() ? 0.0001f : 0.001f;

      float[][] bands = { {h1,25,0.250f,0.7f,5,0,0}, {h2,25,0.125f,0.2f,2,0,0} };

      int num = 1+2*N;

      int[] indices   = new int[num];

      for(int i=1; i<num; i++) indices[i] = 1;

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

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

      int num = 8+3*N;

      int[] indices = new int[num];

      for(int i=1; i<num; i++) indices[i] = -1;

      float[][] centers = {{ 0,0,0 }};

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

      }

    else if( variant==1 )

      {

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

      int num = 1+4*N;

      int[] indices = new int[num];

      for(int i=0; i<num; i++) indices[i] = -1;

      float[][] centers = { { 0,0,0 } };

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

      }

    else

      {

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

      int num = 1+2*N;

      int[] indices = new int[num];

      for(int i=0; i<num; i++) indices[i] = -1;

      float[][] centers = { { 0,0,0 } };

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

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 3;

    }