TwistyPuzzleLib

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

// Copyright 2020 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_OCTAHEDRON;

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

import org.distorted.objectlib.metadata.ListObjects;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.shape.ShapeOctahedron;

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

public class TwistyDiamond extends ShapeOctahedron

{

  // the four rotation axis of a Diamond. Must be normalized.

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D( SQ6/3, SQ3/3,     0),

           new Static3D(-SQ6/3, SQ3/3,     0),

           new Static3D(     0,-SQ3/3,-SQ6/3),

           new Static3D(     0,-SQ3/3, SQ6/3)

         };

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private int[] mTetraToFaceMap;

  private float[][] mPosition;

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

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

    {

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

    }

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

  @Override

  public float[][] returnRotationFactor()

    {

    int numL = getNumLayers()[0];

    float[] f = new float[numL];

    for(int i=0; i<numL; i++) f[i] = 1.5f;

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

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null ) mEdges = ScrambleEdgeGenerator.getScrambleEdgesSingle(mBasicAngle);

    return mEdges;

    }

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

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

    {

    int numL = numLayers[0];

    if( numL<2 ) return null;

    if( mCuts==null )

      {

      mCuts = new float[4][numL-1];

      float cut = (SQ6/6)*(2-numL);

      for(int i=0; i<numL-1; i++)

        {

        mCuts[0][i] = cut;

        mCuts[1][i] = cut;

        mCuts[2][i] = cut;

        mCuts[3][i] = cut;

        cut += SQ6/3;

        }

      }

    return mCuts;

    }

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

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

    {

    int numAxis = ROT_AXIS.length;

    boolean[][] layerRotatable = new boolean[numAxis][];

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

      {

      layerRotatable[i] = new boolean[numLayers[i]];

      for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;

      }

    return layerRotatable;

    }

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

  public int getTouchControlType()

    {

    return TC_OCTAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

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

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlOctahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlOctahedron.FACE_AXIS;

    }

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

  private int getNumOctahedrons(int layers)

    {

    return layers==1 ? 1 : 4*(layers-1)*(layers-1) + 2;

    }

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

  private int getNumTetrahedrons(int layers)

    {

    return 4*layers*(layers-1);

    }

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

  private int createOctaPositions(float[][] centers, int index, int layers, float height)

    {

    float x = (layers-1)*0.5f;

    float z = (layers+1)*0.5f;

    for(int i=0; i<layers; i++, index++)

      {

      z -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-1; i++, index++)

      {

      x -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-1; i++, index++)

      {

      z += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-2; i++, index++)

      {

      x += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    return index;

    }

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

  private int createTetraPositions(float[][] centers, int index, int layers, float height)

    {

    float x = (layers-1)*0.5f;

    float z =  layers*0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      z -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x += 0.5f;

    z -= 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      x -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x -= 0.5f;

    z -= 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      z += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x -= 0.5f;

    z += 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      x += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    return index;

    }

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

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

    {

    if( mPosition==null )

      {

      int layers = numLayers[0];

      int numO = getNumOctahedrons(layers);

      int numT = getNumTetrahedrons(layers);

      int index = 0;

      float height = 0.0f;

      mPosition = new float[numO+numT][3];

      index = createOctaPositions(mPosition,index,layers,height);

      for(int i=layers-1; i>0; i--)

        {

        height += SQ2/2;

        index = createOctaPositions(mPosition,index,i,+height);

        index = createOctaPositions(mPosition,index,i,-height);

        }

      height = SQ2/4;

      for(int i=layers; i>1; i--)

        {

        index = createTetraPositions(mPosition,index,i,+height);

        index = createTetraPositions(mPosition,index,i,-height);

        height += SQ2/2;

        }

      }

    return mPosition;

    }

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

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

    {

    int numL = numLayers[0];

    int numO = getNumOctahedrons(numL);

    if( cubit<numO ) return mObjectQuats[0];

    switch( retFaceTetraBelongsTo(cubit-numO, numL) )

      {

      case 0: return mObjectQuats[0];                   // unit quat

      case 1: return new Static4D(0,-SQ2/2,0,SQ2/2);    //  90 along Y

      case 2: return mObjectQuats[10];                  // 180 along Y

      case 3: return new Static4D(0, SQ2/2,0,SQ2/2);    //  90 along

      case 4: return new Static4D(0,     0,1,    0);    // 180 along Z

      case 5: return mObjectQuats[4];

      case 6: return new Static4D(     1,0,0,    0);    // 180 along X

      case 7: return mObjectQuats[3];

      }

    return null;

    }

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

  private int retFaceTetraBelongsTo(int tetra, int numLayers)

    {

    if( mTetraToFaceMap==null ) mTetraToFaceMap = new int[] {1,2,3,0,5,6,7,4};

    for(int i=numLayers-1; i>0; i--)

      {

      if( tetra < 8*i ) return mTetraToFaceMap[tetra/i];

      tetra -= 8*i;

      }

    return -1;

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      return new float[][]

          {

             { 0.5f,  0.0f, 0.5f},

             { 0.5f,  0.0f,-0.5f},

             {-0.5f,  0.0f,-0.5f},

             {-0.5f,  0.0f, 0.5f},

             { 0.0f, SQ2/2, 0.0f},

             { 0.0f,-SQ2/2, 0.0f}

          };

      }

    else

      {

      return new float[][]

          {

             {-0.5f, SQ2/4, 0.0f},

             { 0.5f, SQ2/4, 0.0f},

             { 0.0f,-SQ2/4, 0.5f},

             { 0.0f,-SQ2/4,-0.5f}

          };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int[][] indices =

          {

             {3,0,4},

             {0,1,4},

             {1,2,4},

             {2,3,4},

             {5,0,3},

             {5,1,0},

             {5,2,1},

             {5,3,2}

          };

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

      }

    else

      {

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

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int numL = getNumLayers()[0];

    int N = numL>3 ? 5:6;

    int E = numL>2 ? (numL>3 ? 0:1) : 2;

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

    int angle = 25;

    float R = 0.7f;

    float S = 0.5f;

    if( variant==0 )

      {

      float[][] bands  = { {height,angle,R,S,N,E,E} };

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

      return new ObjectFaceShape(bands,bandIndices,null);

      }

    else

      {

      float[][] bands  = { {height,angle,R,S,N,E,E} };

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

      return new ObjectFaceShape(bands,bandIndices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

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

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

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

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

      }

    else

      {

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

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

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

      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<getNumOctahedrons(numLayers[0]) ? 0 : 1;

    }

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

  public float getStickerRadius()

    {

    return 0.08f;

    }

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

  public float getStickerStroke()

    {

    float stroke = 0.08f;

    if( isInIconMode() )

      {

      int[] numLayers = getNumLayers();

      switch(numLayers[0])

        {

        case 2: stroke*=1.4f; break;

        case 3: stroke*=2.0f; break;

        case 4: stroke*=2.1f; break;

        default:stroke*=2.2f; break;

        }

      }

    return stroke;

    }

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

  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()

    {

    switch(getNumLayers()[0])

      {

      case 2: return ListObjects.DIAM_2.name();

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

      case 4: return ListObjects.DIAM_4.name();

      }

    return ListObjects.DIAM_2.name();

    }

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

  public String[][] getTutorials()

    {

    int[] numLayers = getNumLayers();

    switch(numLayers[0])

      {

      case 2: return new String[][] {

                          {"gb","R2wrbJJ3izM","How to Solve a Skewb Diamond","Dr. Penguin^3"},

                          {"es","2RCusYQdYYE","Como resolver Skewb Diamond","Tutoriales Rubik"},

                          {"ru","k8B6RFcNoGw","Как собрать Skewb Diamond","Алексей Ярыгин"},

                          {"fr","tqbkgwNcZCE","Comment résoudre le Skewb Diamond","Valentino Cube"},

                          {"de","6ewzrCOnZfg","Octagon lösen","JamesKnopf"},

                          {"pl","61_Z4TpLMBc","Diamond Skewb TUTORIAL PL","MrUk"},

                          {"br","UapwpXMYtH4","Como resolver o Octaedro Diamond","Rafael Cinoto"},

                          {"kr","hVBSlfHVTME","공식 하나만 사용 - 다이아몬드 스큐브","Denzel Washington"},

                          {"tw","tu9KzT4G4rQ","四軸八面體魔術方塊","1hrBLD"},

                         };

      case 3: return new String[][] {

                          {"gb","n_mBSUDLUZw","Face Turning Octahedron Tutorial","SuperAntoniovivaldi"},

                          {"es","ogf0t6fGxZI","FTO - Tutorial en español","Gadi Rubik"},

                          {"ru","VXCjk0bVRoA","Как собрать Face Turning Octahedron","Алексей Ярыгин"},

                          {"de","6bO0AcwY5K8","Face Turning Octahedron - Tutorial","GerCubing"},

                          {"pl","huWg-ZfP-KY","Octahedron cube TUTORIAL PL","MrUk"},

                          {"br","WN3BoP4EbvM","Como resolver o octaedro 3x3 1/3","Rafael Cinoto"},

                          {"br","4zFlfANOliE","Como resolver o octaedro 3x3 2/3","Rafael Cinoto"},

                          {"br","6OvNzoHk7RU","Como resolver o octaedro 3x3 3/3","Rafael Cinoto"},

                          {"vn","KzGQ-mVRsss","Tutorial N.43 - FTO","Duy Thích Rubik"},

                         };

      case 4: return new String[][] {

                          {"gb","3GJkySk5zeQ","Master Face Turning Octahedron","SuperAntoniovivaldi"},

                          {"gb","zW_1htxy52k","Master FTO Tutorial","Michele Regano"},

                          {"es","3K8XL9SBSvs","Tutorial Master FTO de Mf8","Robert Cubes"},

                          {"ru","0CRwhZ2JNJA","Как собрать Master FTO","Алексей Ярыгин"},

                          {"vn","4XdeuGYDCJo","Tutorial N.141 - Master FTO","Duy Thích Rubik"},

                         };

      }

    return null;

    }

}