TwistyPuzzleLib

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

// Copyright 2019 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_DODECAHEDRON;

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

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.touchcontrol.TouchControlDodecahedron;

import org.distorted.objectlib.metadata.ListObjects;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.shape.ShapeDodecahedron;

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

public class TwistyUltimate extends ShapeDodecahedron

{

  private static final float A = (float)Math.sqrt(21*SQ5+47);

  private static final float B = SQ6*(5*SQ5+11)/(6*A);

  private static final float C = SQ6*(  SQ5+ 2)/(3*A);

  private static final float D = SQ3/3;

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

  private static final float G = (SQ5+3)/4;

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D( B,0,C ),

           new Static3D( C,B,0 ),

           new Static3D(-D,D,D ),

           new Static3D( 0,C,-B)

         };

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPositions;

  private int[] mQuatIndex;

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

  public TwistyUltimate(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 = ScrambleEdgeGenerator.getScrambleEdgesSingle(mBasicAngle);

    return mEdges;

    }

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

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

    {

    if( mPositions==null )

      {

      mPositions = new float[][]

         {

           {   0,  -1, 2*G },

           { 2*E,-2*E,-2*E },

           {-2*G,   0,  -1 },

           {   1, 2*G,   0 },

           {-2*E,  2*E, 2*E },

           { 2*G,    0,   1 },

           {  -1, -2*G,   0 },

           {   0,    1,-2*G },

           {        E, (E+0.5f),    (E+G) },

           {   -(E+G),       -E, (E+0.5f) },

           { (E+0.5f),   -(E+G),        E },

           {       -E,-(E+0.5f),   -(E+G) },

           {    (E+G),        E,-(E+0.5f) },

           {-(E+0.5f),    (E+G),       -E }

         };

      }

    return mPositions;

    }

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

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

    {

    if( mQuatIndex==null ) mQuatIndex = new int[] { 0,2,5,6,

                                                    0,8,2,1,

                                                    0,5,8,9,1,6 };

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      return new float[][]

         {

           { 0     , 0     , 0      },

           { -E    , E+0.5f, -0.5f  },

           {-0.5f  , -E    , -E-0.5f},

           { E+0.5f, 0.5f  , -E     },

           { 0     , 1     , -2*E-1 },

           { 0     , 1     , 0      },

           { -E    ,-E+0.5f, -0.5f  },

           {  E    ,-E+0.5f, -0.5f  }

         };

      }

    else if( variant==1 )

      {

      return new float[][]

         {

            {         0.00f,         0.00f,         0.00f},

            {       - 0.50f,-SQ5/4 - 0.25f,-SQ5/4 - 0.75f},

            { SQ5/4 + 0.25f,-SQ5/4 - 0.75f,       + 0.50f},

            { SQ5/4 + 0.75f,       + 0.50f,-SQ5/4 - 0.25f},

            { SQ5/2 + 0.50f,-SQ5/2 - 0.50f,-SQ5/2 - 0.50f},

            { SQ5/4 - 0.25f,       + 0.50f,-SQ5/4 - 0.25f},

            {       - 0.50f,-SQ5/4 - 0.25f,-SQ5/4 + 0.25f},

            { SQ5/4 + 0.25f,-SQ5/4 + 0.25f,       + 0.50f}

         };

      }

    else

      {

      return new float[][]

         {

           {  -E     ,-E+0.5f,     0.5f},

           {   E     , E-0.5f,    -0.5f},

           {-2*E     ,   0.0f,     0.0f},

           {     0.5f, E     ,  -E-0.5f},

           {  -E     ,-E-0.5f,     0.5f},

           {   E+0.5f,  -0.5f,  -E     },

           {-2*E     ,  -1.0f,     0.0f},

           {     1.0f,   0.0f,-2*E     },

           {-2*E+0.5f, E     ,  -E-0.5f},

           {     0.5f,-E-1.0f,  -E+0.5f},

           {  -E     ,-E-0.5f,-2*E-0.5f}

         };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int[][] indices =

         {

           {6,0,5,1},

           {0,7,3,5},

           {0,6,2,7},

           {1,5,3,4},

           {3,7,2,4},

           {2,6,1,4},

         };

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

      }

    else if( variant==1 )

      {

      int[][] indices =

         {

           {6,0,5,1},

           {0,7,3,5},

           {0,6,2,7},

           {1,5,3,4},

           {3,7,2,4},

           {2,6,1,4},

         };

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

      }

    else

      {

      int[][] indices =

         {

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

           {0,4,9,5,1},

           { 0,2,6,4},

           { 1,5,7,3},

           {10,9,4,6},

           {7,5,9,10},

           {10,8,3,7},

           {6,2,8,10}

         };

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int angle = 25;

    float R = 0.7f;

    float S = 0.5f;

    if( variant==0 )

      {

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

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

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

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else if( variant==1 )

      {

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

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

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

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

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

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

      float h3 = isInIconMode() ? 0.001f : 0.01f;

      float[][] bands = { {h1,angle,R,S,5,1,0}, {h2,angle,R,S,5,1,0}, {h3,angle,R,S,5,1,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

      float[][] corners   = { { 0.013f, 0.16f } };

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

      float[][] centers   = { { 0.0f,-1.0f, -(SQ5+3)/2 } };

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

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

      }

    else if( variant==1 )

      {

      float[][] corners   = { { 0.013f, 0.16f } };

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

      float[][] centers   = { { 0.0f,-1.0f, -(SQ5+3)/2 } };

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

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

      }

    else

      {

      float[][] corners   = { { 0.013f, 0.16f } };

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

      float[][] centers   = { { -(SQ5+1)/4, 0.5f, -(SQ5+5)/4 } };

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

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

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 3;

    }

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

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

    {

    return cubit<4 ? 0 : (cubit<8 ? 1:2);

    }

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

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

    {

    if( mCuts==null )

      {

      float[] cut = new float[] {0.0f};

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

      }

    return mCuts;

    }

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

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

    {

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

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

    }

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

  public int getTouchControlType()

    {

    return TC_DODECAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

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

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlDodecahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlDodecahedron.FACE_AXIS;

    }

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

  public float getStickerRadius()

    {

    return 0.18f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.22f : 0.15f;

    }

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

  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] = 3;

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

      }

    return mBasicAngle;

    }

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

  public String getShortName()

    {

    return ListObjects.ULTI_2.name();

    }

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

  public String[][] getTutorials()

    {

    return new String[][]{

                          {"gb","n1ikPKZxGEo","Ultimate Skewb Tutorial","BeardedCubing"},

                          {"es","wNL1WJ_sCfs","Resolver Skewb ULTIMATE","Cuby"},

                          {"ru","ifkM8Rr3Y8E","Как собрать Скьюб Ультимейт","Алексей Ярыгин"},

                          {"fr","r_eoNcejdrA","Résoudre le Skewb Ultimate","ValentinoCube"},

                          {"de","16ioOywTVvI","Skewb Ultimate - Tutorial","GerCubing"},

                          {"pl","8MsyPs1VB8U","Ultimate skewb TUTORIAL PL","MrUK"},

                          {"kr","VOt9_K48c0k","스큐브 얼티미트 공식","노케빈"},

                          {"vn","VOt9_K48c0k","Tutorial N.147 - Skewb Ultimate","Duy Thích Rubik"},

                         };

    }

}