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.TouchControlDodecahedron.COS54;

import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.SIN54;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.library.helpers.QuatHelper;

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

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectSignatures;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

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

public class TwistyMegaminx extends TwistyDodecahedron

{

  static final float MEGA_D = 0.04f;

  private int[] mQuatCenterIndices;

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

  public TwistyMegaminx(int meshState, int iconMode, Static4D quat, Static3D move, float scale, InitData data, InitAssets asset)

    {

    super(meshState, iconMode, quat, move, scale, data, asset);

    }

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

  private void initializeCenterIndices()

    {

    mQuatCenterIndices = new int[] { 0, 35, 55, 38, 48, 41, 42, 58, 57, 46, 29, 59 };

    }

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

  private int numCubitsPerCorner(int numLayers)

    {

    return 3*((numLayers-1)/2)*((numLayers-3)/2) + 1;

    }

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

  private int numCubitsPerEdge(int numLayers)

    {

    return numLayers-2;

    }

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

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

    {

    return genericGetCuts(numLayers[0],0.5f-MEGA_D);

    }

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

  private float[] computeCenter(int center, int numLayers)

    {

    if( mCenterCoords==null ) initializeCenterCoords();

    float[] coords = mCenterCoords[center];

    float A = (float)numLayers/3;

    return new float[] { A*coords[0], A*coords[1], A*coords[2] };

    }

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

// Fill out mCurrCorner{X,Y,Z} by applying appropriate Quat to mBasicCorner{X,Y,Z}

// Appropriate one: QUATS[QUAT_INDICES[corner]].

  private void computeBasicCornerVectors(int corner)

    {

    if( mQuatCornerIndices==null ) initializeQuatIndices();

    if( mCurrCornerV==null || mBasicCornerV==null ) initializeCornerV();

    Static4D quat = mObjectQuats[mQuatCornerIndices[corner]];

    mCurrCornerV[0] = QuatHelper.rotateVectorByQuat(mBasicCornerV[0],quat);

    mCurrCornerV[1] = QuatHelper.rotateVectorByQuat(mBasicCornerV[1],quat);

    mCurrCornerV[2] = QuatHelper.rotateVectorByQuat(mBasicCornerV[2],quat);

    }

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

  private float[] computeCorner(int numCubitsPerCorner, int numLayers, int corner, int part)

    {

    if( mCorners==null ) initializeCorners();

    if( mCurrCornerV==null || mBasicCornerV==null ) initializeCornerV();

    float D = numLayers/3.0f;

    float[] corn = mCorners[corner];

    if( part==0 )

      {

      return new float[] { corn[0]*D, corn[1]*D, corn[2]*D };

      }

    else

      {

      float E = 2.0f*D*(0.5f-MEGA_D)/(0.5f*(numLayers-1));

      int N = (numCubitsPerCorner-1)/3;

      int block = (part-1) % N;

      int index = (part-1) / N;

      Static4D pri = mCurrCornerV[index];

      Static4D sec = mCurrCornerV[(index+2)%3];

      int layers= (numLayers-3)/2;

      int multP = (block % layers) + 1;

      int multS = (block / layers);

      return new float[] {

                          corn[0]*D + (pri.get0()*multP + sec.get0()*multS)*E,

                          corn[1]*D + (pri.get1()*multP + sec.get1()*multS)*E,

                          corn[2]*D + (pri.get2()*multP + sec.get2()*multS)*E

                         };

      }

    }

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

  private int computeEdgeType(int cubit, int numCubitsPerCorner, int numCubitsPerEdge)

    {

    int part = (cubit - NUM_CORNERS*numCubitsPerCorner) % numCubitsPerEdge;

    return (part+1)/2;

    }

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

  private float[] computeEdge(int numLayers, int edge, int part)

    {

    if( mCenterCoords==null ) initializeCenterCoords();

    if( mCorners==null ) initializeCorners();

    if( mEdgeMap==null ) initializeEdgeMap();

    float D = numLayers/3.0f;

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

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

    float x = D * (c1[0]+c2[0]) / 2;

    float y = D * (c1[1]+c2[1]) / 2;

    float z = D * (c1[2]+c2[2]) / 2;

    if( part==0 )

      {

      return new float[] { x, y, z };

      }

    else

      {

      int mult = (part+1)/2;

      int dir  = (part+1)%2;

      float[] center = mCenterCoords[ mEdgeMap[edge][dir+2] ];

      float vX = D*center[0] - x;

      float vY = D*center[1] - y;

      float vZ = D*center[2] - z;

      float A = 3*mult*D*(0.5f-MEGA_D)*COS18/((numLayers-1)*0.5f);

      A /= (float)Math.sqrt(vX*vX+vY*vY+vZ*vZ);

      return new float[] { x+A*vX, y+A*vY, z+A*vZ };

      }

    }

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

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

    {

    int numL = numLayers[0];

    int numCubitsPerCorner = numCubitsPerCorner(numL);

    int numCubitsPerEdge   = numCubitsPerEdge(numL);

    int numCubits = NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge + NUM_CENTERS;

    int index=0;

    final float[][] CENTERS = new float[numCubits][];

    for(int corner=0; corner<NUM_CORNERS; corner++)

      {

      computeBasicCornerVectors(corner);

      for(int part=0; part<numCubitsPerCorner; part++, index++)

        {

        CENTERS[index] = computeCorner(numCubitsPerCorner,numL,corner,part);

        }

      }

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

      {

      for(int part=0; part<numCubitsPerEdge; part++, index++)

        {

        CENTERS[index] = computeEdge(numL, edge, part );

        }

      }

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

      {

      CENTERS[index] = computeCenter(center, numL);

      }

    return CENTERS;

    }

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

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

    {

    int numL = numLayers[0];

    int numCubitsPerCorner = numCubitsPerCorner(numL);

    int numCubitsPerEdge   = numCubitsPerEdge(numL);

    return mObjectQuats[getQuat(cubit,numCubitsPerCorner,numCubitsPerEdge)];

    }

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

  private int getQuat(int cubit, int numCubitsPerCorner, int numCubitsPerEdge)

    {

    if( mQuatCornerIndices==null || mQuatEdgeIndices==null ) initializeQuatIndices();

    if( mQuatCenterIndices==null ) initializeCenterIndices();

    if( cubit < NUM_CORNERS*numCubitsPerCorner )

      {

      int corner = cubit/numCubitsPerCorner;

      return mQuatCornerIndices[corner];

      }

    if( cubit < NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge )

      {

      int edge = (cubit-NUM_CORNERS*numCubitsPerCorner)/numCubitsPerEdge;

      return mQuatEdgeIndices[edge];

      }

    int center = cubit - NUM_CORNERS*numCubitsPerCorner - NUM_EDGES*numCubitsPerEdge;

    return mQuatCenterIndices[center];

    }

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

  private float[][] getVertices(int variant)

    {

    int[] numLayers = getNumLayers();

    int numVariants = getNumCubitVariants(numLayers);

    int numL        = numLayers[0];

    if( variant==0 )

      {

      float width = numL*(0.5f-MEGA_D)/(0.5f*(numL-1));

      float X = width*COS18*SIN_HALFD;

      float Y = width*SIN18;

      float Z = width*COS18*COS_HALFD;

      return new float[][]

        {

            {   0,   0      ,   0 },

            {   X,   Y      ,  -Z },

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

            {  -X,   Y      ,  -Z },

            {   0,   0-width,   0 },

            {   X,   Y-width,  -Z },

            {   0, 2*Y-width,-2*Z },

            {  -X,   Y-width,  -Z },

        };

      }

    else if( variant<numVariants-1 )

      {

      int type = variant-1;

      float height= numL*(0.5f-MEGA_D)*COS18/((numL-1)*0.5f);

      float width = numL*2*MEGA_D + 2*type*height*SIN18/COS18;

      float W = width/2;

      float X = height*SIN_HALFD;

      float Y = height*SIN18/COS18;

      float Z = height*COS_HALFD;

      return new float[][]

        {

            {   0,   W   ,   0 },

            {   X, W+Y   ,  -Z },

            {   0, W+2*Y ,-2*Z },

            {  -X, W+Y   ,  -Z },

            {   0,  -W   ,   0 },

            {   X,-W-Y   ,  -Z },

            {   0,-W-2*Y ,-2*Z },

            {  -X,-W-Y   ,  -Z },

        };

      }

    else

      {

      float width = 2*numL*(MEGA_D+(0.5f-MEGA_D)*SIN18);

      final double ANGLE = 0.825f*Math.PI;

      final float cosA  = (float)Math.cos(ANGLE);

      final float sinA  = (float)Math.sin(ANGLE);

      float R  = 0.5f*width/COS54;

      float X1 = R*COS54;

      float Y1 = R*SIN54;

      float X2 = R*COS18;

      float Y2 = R*SIN18;

      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 , R*cosA ,-R*sinA }

        };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    int[] numLayers = getNumLayers();

    int numVariants = getNumCubitVariants(numLayers);

    if( variant==0 )

      {

      int[][] indices =

        {

            {4,5,1,0},

            {7,4,0,3},

            {0,1,2,3},

            {7,6,5,4},

            {2,1,5,6},

            {3,2,6,7}

        };

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

      }

    if( variant<numVariants-1 )

      {

      int[][] indices =

        {

            {4,5,1,0},

            {7,4,0,3},

            {3,2,6,7},

            {2,1,5,6},

            {0,1,2,3},

            {7,6,5,4}

        };

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

      }

    else

      {

      int[][] indices =

        {

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

          {5,1,0},

          {5,2,1},

          {5,3,2},

          {5,4,3},

          {5,0,4}

        };

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int[] numLayers = getNumLayers();

    int numVariants = getNumCubitVariants(numLayers);

    int numL        = numLayers[0];

    boolean small   = numL<=3;

    if( variant==0 )

      {

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

      float[][] bands = { {h1,34,0.3f,0.2f,3,0,0}, {0.001f,10,0.0f,0.0f,2,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    if( variant<numVariants-1 )

      {

      int N = small ? 5 : 3;

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

      float[][] bands = { {h1,34,0.2f,0.2f,N,0,0},{0.001f,34,0.3f,0.2f,2,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

      float width = 2*numL*(MEGA_D+(0.5f-MEGA_D)*SIN18);

      float R  = 0.5f*width/COS54;

      int N = small ? 4 : 3;

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

      float[][] bands = { { h1,45, R/3,0.2f,N,0,0},{0.001f,45, R/3,0.2f,2,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

      int[] numLayers = getNumLayers();

      int numL        = numLayers[0];

      float width = numL*(0.5f-MEGA_D)/(0.5f*(numL-1));

      float Y = width*SIN18;

      float Z = width*COS18*COS_HALFD;

      float[][] corners   = { {0.03f,0.15f}, {0.02f,0.10f} };

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

      float[][] centers   = { { 0.0f, 2*Y-width,-2*Z } };

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

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

      }

    else

      {

      return null;

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 2 + numLayers[0]/2;

    }

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

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

    {

    int numL = numLayers[0];

    int numCubitsPerCorner = numCubitsPerCorner(numL);

    if( cubit<NUM_CORNERS*numCubitsPerCorner ) return 0;

    int numCubitsPerEdge = numCubitsPerEdge(numL);

    if( cubit<NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge )

      {

      int type = computeEdgeType(cubit,numCubitsPerCorner,numCubitsPerEdge);

      return type+1;

      }

    return getNumCubitVariants(numLayers)-1;

    }

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

  public float getStickerRadius()

    {

    return 0.13f;

    }

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

  public float getStickerStroke()

    {

    float stroke = 0.18f;

    if( isInIconMode() )

      {

      int[] numLayers = getNumLayers();

      stroke*= ( numLayers[0]==3 ? 1.5f : 2.2f );

      }

    return stroke;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

  public String getShortName()

    {

    switch(getNumLayers()[0])

      {

      case 3: return ObjectType.MEGA_3.name();

      case 5: return ObjectType.MEGA_5.name();

      }

    return ObjectType.MEGA_3.name();

    }

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

  public ObjectSignature getSignature()

    {

    switch(getNumLayers()[0])

      {

      case 3: return new ObjectSignature(ObjectSignatures.MEGA_3);

      case 5: return new ObjectSignature(ObjectSignatures.MEGA_5);

      }

    return null;

    }

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

  public String getObjectName()

    {

    switch(getNumLayers()[0])

      {

      case 3: return "Megaminx";

      case 5: return "Gigaminx";

      }

    return "Megaminx";

    }

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

  public String getInventor()

    {

    switch(getNumLayers()[0])

      {

      case 3: return "Ferenc Szlivka";

      case 5: return "Tyler Fox";

      }

    return "Ferenc Szlivka";

    }

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

  public int getYearOfInvention()

    {

    switch(getNumLayers()[0])

      {

      case 3: return 1982;

      case 5: return 2006;

      }

    return 2006;

    }

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

  public int getComplexity()

    {

    switch(getNumLayers()[0])

      {

      case 3: return 3;

      case 5: return 4;

      }

    return 9;

    }

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

  public String[][] getTutorials()

    {

    int[] numLayers = getNumLayers();

    switch(numLayers[0])

      {

      case 3: return new String[][] {

                          {"gb","j4x61L5Onzk","How to Solve the Megaminx","Z3"},

                          {"es","xuKbT6Il0Ko","Resolver Megaminx","Cuby"},

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

                          {"fr","Ln1vl85puKo","Résoudre le Megaminx","Victor Colin"},

                          {"de","d-GQD6CBdB8","Megaminx lösen","Pezcraft"},

                          {"pl","BZTW6ApeRZE","Jak ułożyć: Megaminx","DżoDżo"},

                          {"br","0BTzkDZW078","Como resolver o Megaminx 1/2","Pedro Filho"},

                          {"br","VVHzZI73BN0","Como resolver o Megaminx 2/2","Pedro Filho"},

                          {"kr","2NUsMclrD-0","메가밍크스 예시솔빙","iamzoone"},

                          {"vn","wRN3t91vD8w","Tutorial N.9 - Megaminx","Duy Thích Rubik"},

                         };

      case 5: return new String[][] {

                          {"gb","MNBMm8BnHtQ","Solve the Gigaminx Part 1","BeardedCubing"},

                          {"gb","QrrP4GwqVMw","Solve the Gigaminx Part 2","BeardedCubing"},

                          {"es","ex5EQMBxV1U","Tutorial Gigaminx","RubikArt"},

                          {"ru","UJYK3SHjSGg","Как собрать Гигаминкс ч.1","Артем Мартиросов"},

                          {"ru","-iBCpr4Gwsw","Как собрать Гигаминкс ч.2","Артем Мартиросов"},

                          {"ru","4-dI7NCW8n8","Как собрать Гигаминкс ч.3","Артем Мартиросов"},

                          {"fr","e485fh0V1dg","Résolution du Gigaminx","Asthalis"},

                          {"de","APSAj4UtOAg","Megaminx 5x5 lösen","JamesKnopf"},

                          {"pl","qbKLMCX1wKg","Jak ułożyć Gigaminxa cz.1","chomik19751"},

                          {"pl","JQOXD3qleH4","Jak ułożyć Gigaminxa cz.2","chomik19751"},

                          {"pl","WF2katJ22FA","Jak ułożyć Gigaminxa cz.3","chomik19751"},

                          {"pl","jlyRrJjH4qQ","Jak ułożyć Gigaminxa cz.4","chomik19751"},

                          {"kr","HfPFrWuz6z4","기가밍크스 gigaminx","큐브놀이터"},

                          {"vn","yJzejHqZscY","Tutorial N.49 - Gigaminx","Duy Thích Rubik"},

                         };

      }

    return null;

    }

}