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.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 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 TwistyStarminx extends TwistyDodecahedron

{

  private float[][] mCuts;

  private float[][] mPosition;

  private int[] mQuatIndex;

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

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

    {

    super(iconMode, quat, move, scale, meta, asset);

    }

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

  @Override

  public int getInternalColor()

    {

    return 0xff222222;

    }

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

  @Override

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

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

      };

    }

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

  private void setQuatIndex()

    {

    if( mQuatIndex==null )

      {

      mQuatIndex = new int[]

        {

         0,17,12,13,20, 4,25, 5,24,16,

         9,21, 1,34, 8,11,30,43,26,14,

        15,45,33,28,10, 2,29, 6, 7, 3,

         0,35,55,38,48,41,42,58,57,46,29,59,

         0,36,44, 29, 2, 7, 59,20,24, 48,42,58,

        18,13,50, 53,41,43, 22,16,39, 49,33,38,

        11, 8,34, 54,51,56, 10, 1,47, 52,25,32,

        17,12,35, 27,30,46, 19, 4,31, 26, 3,14,

         9,21,55, 28,37,57, 23, 5,40, 45, 6,15

        };

      }

    }

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

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

    {

    if( mPosition==null )

      {

      if( mEdgeMap==null ) mEdgeMap = initializeEdgeMap();

      if( mCenterCoords==null ) initializeCenterCoords();

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

      for(int edge=0; edge<NUM_EDGES; edge++)

        {

        float[] c1 = mCorners[ mEdgeMap[edge][0] ];

        float[] c2 = mCorners[ mEdgeMap[edge][1] ];

        mPosition[edge][0] = (c1[0]+c2[0])/2;

        mPosition[edge][1] = (c1[1]+c2[1])/2;

        mPosition[edge][2] = (c1[2]+c2[2])/2;

        }

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

        {

        int index = center+NUM_EDGES;

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

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

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

        }

      float A = 1.5f;

      float B = 3*C2;

      float K = 1/(4*SIN54*SIN54);

      float Y = (B-A)*K/2;

      float Z = B*K/2;

      float[] result = new float[4];

      setQuatIndex();

      for(int petal=0; petal<3*NUM_CORNERS; petal++)

        {

        int index  = petal+NUM_EDGES+NUM_CENTERS;

        int corner = petal/3;

        QuatHelper.rotateVectorByQuat(result,0.0f,Y,-Z,1.0f, mObjectQuats[mQuatIndex[index]] );

        mPosition[index][0] = mCorners[corner][0] + result[0];

        mPosition[index][1] = mCorners[corner][1] + result[1];

        mPosition[index][2] = mCorners[corner][2] + result[2];

        }

      }

    return mPosition;

    }

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

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

    {

    setQuatIndex();

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      float A = 1.5f;

      float B = 3*C2;

      float C = 3*SIN54;

      float X = (A*C)/(A+C);

      float Z1= A*(B-C)/(A+C);

      float Z2= B-A;

      return new float[][]

         {

             { 0, A,  0 },

             { 0,-A,  0 },

             {-X, 0,-Z1 },

             {+X, 0,-Z1 },

             {-X, 0,-Z2 },

             {+X, 0,-Z2 },

         };

      }

    else if( variant==1 )

      {

      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 X1 = R*COS54;

      float Y1 = R*SIN54;

      float X2 = R*COS18;

      float Y2 = R*SIN18;

      float Z  = 1.6f*R;  // about

      return new float[][]

        {

          {-X1,-Y1*sinA,-Y1*cosA},

          {-X2, Y2*sinA, Y2*cosA},

          { 0 , R*sinA , R*cosA },

          {+X2, Y2*sinA, Y2*cosA},

          {+X1,-Y1*sinA,-Y1*cosA},

          { 0 , Z*cosA ,-Z*sinA }

        };

      }

    else

      {

      float A = 1.5f;

      float B = 3*C2;

      float K = 1/(4*SIN54*SIN54);

      float X = A*K;

      float Y = (B-A)*K/2;

      float Z = B*K/2;

      return new float[][]

         {

             { 0,-Y,   Z },

             {-X, Y,  -Z },

             {+X, Y,  -Z },

             { 0,-Y,-3*Z },

         };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 ) // edge

      {

      int[][] indices =

         {

             {2,1,0},

             {3,0,1},

             {2,4,1},

             {2,0,4},

             {3,1,5},

             {3,5,0},

             {1,5,4},

             {0,4,5}

         };

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

      }

    if( variant==1 ) // center

      {

      int[][] indices =

        {

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

          {5,1,0},

          {5,2,1},

          {5,3,2},

          {5,4,3},

          {5,0,4}

        };

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

      }

    else

      {

      int[][] indices =

         {

             {2,1,0},

             {1,2,3},

             {2,0,3},

             {1,3,0}

         };

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int angle = 15;

    float R = 0.7f;

    float S = 0.5f;

    if( variant==0 )

      {

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

      float[][] bands = { {h1,angle,R,S,5,1,0}, {0.001f,angle,R,S,4,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else if( variant==1 )

      {

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

      float[][] bands = { {h1,angle,R,S,4,0,0}, {0.001f,angle,R,S,3,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

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

      float[][] bands = { {h1,angle,R,S,5,0,0}, {0.001f,angle,R,S,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.025f, 0.20f } };

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

      float[][] centers = { { 0.0f,0.0f,-1.0f } };

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

      }

    else if( variant==1 )

      {

      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  = 2.0f*(TAN54-(1/TAN54));

      float[][] corners = { { 0.015f, 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);

      }

    else

      {

      float Z = 3*C2/(4*SIN54*SIN54);

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

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

      float[][] centers = { { 0.0f,0.0f,-Z } };

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

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 3;

    }

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

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

    {

    return cubit<NUM_EDGES ? 0: (cubit<NUM_CENTERS+NUM_EDGES ? 1:2);

    }

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

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

    {

    if( mCuts==null )

      {

      float CUT = 1.0f; // about

      float[] cut = new float[] { -CUT,+CUT };

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

      }

    return mCuts;

    }

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

  public float getStickerRadius()

    {

    return 0.18f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.22f : 0.15f;

    }

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

  public float[][][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public String getShortName()

    {

    return ListObjects.STAR_3.name();

    }

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

  public String[][] getTutorials()

    {

    return new String[][]{

                          {"gb","NqYFonhf2rw","Face Turning Starminx Tutorial","twistypuzzling"},

                          {"pl","7LotUfg90HI","Starminx Cube TUTORIAL PL 1/2","MrUK"},

                          {"pl","nH2doGM1Das","Starminx Cube TUTORIAL PL 2/2","MrUK"},

                          {"kr","8bIQVCKWBvw","스타밍크스 해법  1/2","듀나메스 큐브 해법연구소"},

                          {"kr","4WU5iJyM7jI","스타밍크스 해법  2/2","듀나메스 큐브 해법연구소"},

                          {"vn","QhSaboIX3Fs","Tutorial N.183 - Starminx","Duy Thích Rubik"},

                         };

    }

}