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

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

import java.io.InputStream;

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

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.ObjectSignatures;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.shape.ShapeHexahedron;

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

public class TwistyIvy 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)

         };

  public static final float IVY_D = 0.006f;

  private static final int  IVY_N = 8;

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private int[] mQuatIndex;

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

  public TwistyIvy(InitData data, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(data, meshState, iconMode, data.getNumLayers()[0], quat, move, scale, stream);

    }

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

// ditto, manually provide the sticker coordinates.

  @Override

  public void adjustStickerCoords()

    {

    float B = 1.08f;

    float A1 = B*0.41f;

    float A2 = B*0.46f;

    mStickerCoords = new float[][]

          {

            { 0.29258922f, -0.5f, 0.29258922f, 0.29258922f, -0.5f, 0.29258922f },

            { -A1,A1,A2,-A2 }

          };

    }

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

  public int[][] getScrambleEdges()

    {

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

    return mEdges;

    }

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

  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)

    {

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

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_SPLIT_CORNER;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

          {{0},{3},{3},{0}},

          {{2},{1},{1},{2}},

          {{2},{0},{0},{2}},

          {{1},{3},{3},{1}},

          {{0},{0},{1},{1}},

          {{2},{2},{3},{3}},

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlHexahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

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

    {

    final float DIST_CORNER = numLayers[0]-1;

    final float DIST_CENTER = numLayers[0]-1;

    return new float[][]

      {

        { DIST_CORNER, DIST_CORNER, DIST_CORNER },

        {-DIST_CORNER, DIST_CORNER,-DIST_CORNER },

        {-DIST_CORNER,-DIST_CORNER, DIST_CORNER },

        { DIST_CORNER,-DIST_CORNER,-DIST_CORNER },

        { DIST_CENTER,           0,           0 },

        {-DIST_CENTER,           0,           0 },

        {           0, DIST_CENTER,           0 },

        {           0,-DIST_CENTER,           0 },

        {           0,           0, DIST_CENTER },

        {           0,           0,-DIST_CENTER },

      };

    }

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

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

    {

    if( mQuatIndex==null ) mQuatIndex = new int[] { 0,11,10, 9,

                                                    5, 8, 7, 6, 0, 11

                                                  };

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

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

    final float CORR  = 1-2*IVY_D;

    if( variant==0 )

      {

      final float A = 0.3f;

      final int N1 = 4;

      final int N2 = N1 + IVY_N + 1;

      final int N3 = N2 + IVY_N + 1;

      float[][] vertices= new float[3*(IVY_N+1)+5][3];

      vertices[3*(IVY_N+1)+4][0] = -A;

      vertices[3*(IVY_N+1)+4][1] = -A;

      vertices[3*(IVY_N+1)+4][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<=IVY_N; i++)

        {

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

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

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

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

        vertices[N1+i][0] = CORR*(2*cos1-1) - 1;

        vertices[N1+i][1] = CORR*(2*sin1-1) - 1;

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

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

        vertices[N2+i][1] = CORR*(2*sin2-1) - 1;

        vertices[N2+i][2] = CORR*(2*cos2-1) - 1;

        vertices[N3+i][0] = CORR*(2*cos2-1) - 1;

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

        vertices[N3+i][2] = CORR*(2*sin2-1) - 1;

        }

      return vertices;

      }

    else

      {

      float[][] vertices= new float[2*IVY_N+1][3];

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

        {

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

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

        vertices[i      ][0] = CORR*(1-2*cos);

        vertices[i      ][1] = CORR*(1-2*sin);

        vertices[i      ][2] = 0;

        vertices[i+IVY_N][0] = CORR*(2*cos-1);

        vertices[i+IVY_N][1] = CORR*(2*sin-1);

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

        }

      vertices[2*IVY_N][0] = 0.0f;

      vertices[2*IVY_N][1] = 0.0f;

      vertices[2*IVY_N][2] =-0.1f;

      return vertices;

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int[][] indices = new int[3*IVY_N+3][];

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

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

      indices[2] = new int[IVY_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 + IVY_N + 1;

      int N3 = N2 + IVY_N + 1;

      for(int i=0; i<=IVY_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<IVY_N; i++)

        {

        indices[3*i+3] = new int[] { N1+i+1, N1+i, 3*(IVY_N+1)+4 };

        indices[3*i+4] = new int[] { N2+i+1, N2+i, 3*(IVY_N+1)+4 };

        indices[3*i+5] = new int[] { N3+i+1, N3+i, 3*(IVY_N+1)+4 };

        }

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

      }

    else

      {

      int[][] indices= new int[2*IVY_N+1][];

      indices[0] = new int[2*IVY_N+1];

      for(int i=0; i<2*IVY_N; i++)

        {

        indices[0][i] = i;

        indices[i+1]  = new int[] {i+1,i,2*IVY_N};

        }

      indices[2*IVY_N][0] = 0;

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

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

      float[][] bands = { {height,20,0.2f,0.5f,7,1,2}, {0.001f,1,0.2f,0.0f,2,0,0} };

      int[] indices   = new int[3*(IVY_N+1)];

      for(int i=0; i<3*(IVY_N+1); i++) indices[i] = 1;

      indices[0] = indices[1] = indices[2] = 0;

      float C = 1-SQ2/2;

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

      return new ObjectFaceShape(bands,indices,convexCenter);

      }

    else

      {

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

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

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

      int[] indices= new int[2*IVY_N+1];

      for(int i=0; i<2*IVY_N+1; i++) indices[i] = 1;

      indices[0] = 0;

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

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

      float[][] corners  = { {0.04f,0.20f}, {0.03f,0.20f} };

      int[] cornerIndices= new int[3*(IVY_N+1)+5];

      int[] centerIndices= new int[3*(IVY_N+1)+5];

      for(int i=0; i<3*(IVY_N+1); i++)

        {

        cornerIndices[i+4] = -1;

        centerIndices[i+4] = -1;

        }

      cornerIndices[3*(IVY_N+1)+4] = -1;

      centerIndices[3*(IVY_N+1)+4] = -1;

      cornerIndices[0] = 1;

      cornerIndices[1] = 0;

      cornerIndices[2] = 0;

      cornerIndices[3] = 0;

      centerIndices[0] = 0;

      centerIndices[1] = 0;

      centerIndices[2] = 0;

      centerIndices[3] = 0;

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

      }

    else

      {

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

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

      int[] indices = new int[2*IVY_N+1];

      for(int i=0; i<2*IVY_N+1; i++) indices[i] = -1;

      indices[0] = indices[IVY_N] = 0;

      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<4 ? 0:1;

    }

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

  public float getStickerRadius()

    {

    return 0.19f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.16f : 0.12f;

    }

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

  public float[][] getStickerAngles()

    {

    float D = (float)(Math.PI/4);

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

    }

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

// 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 ObjectType.IVY_2.name();

    }

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

  public ObjectSignature getSignature()

    {

    return new ObjectSignature(ObjectSignatures.IVY_2);

    }

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

  public String getObjectName()

    {

    return "Ivy Cube";

    }

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

  public String getInventor()

    {

    return "Eitan Cher";

    }

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

  public int getYearOfInvention()

    {

    return 2009;

    }

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

  public int getComplexity()

    {

    return 0;

    }

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

  public String[][] getTutorials()

    {

    return new String[][]{

                          {"gb","QMzeJobSu1M","How to Solve the Ivy Cube","Z3"},

                          {"es","2-Gf2cmEJDs","Resolver Ivy Cube","Cuby"},

                          {"ru","pbkfOCnnfsA","Как собрать Иви куб","Алексей Ярыгин"},

                          {"fr","mn7YTnYu3Uc","Comment résoudre le Ivy Cube","ValentinoCube"},

                          {"de","vaW5fSUG_O8","Ivy Cube","ThomasStadler"},

                          {"pl","8s_0VxNvFA8","Jak ułożyć Ivy Cube","DubiCube"},

                          {"kr","TmSPgjtSFac","15분만에 아이비큐브 완전정복하기!","초등취미생활"},

                          {"vn","Ktx9KQr_8qo","Tutorial N.29 - Ivy Cube","Duy Thích Rubik"},

                         };

    }

}