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

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.metadata.ListObjects;

import org.distorted.objectlib.helpers.ObjectShape;

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

public class TwistyKilominx extends TwistyDodecahedron

{

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

    {

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

    }

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

  @Override

  protected float[][][] getStickerRadii()

    {

    int[] numLayers = getNumLayers();

    float R = 0.18f;

    float L = 0.50f;

    float[][] t1 = {{ R,L,R,R }};

    float[][] t2 = {{ R,R,R,R }};

    if( numLayers[0]==3 ) return new float[][][] { t1 };

    else                  return new float[][][] { t2,t2,t2,t1 };

    }

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

  private int numCubitsPerCorner(int numLayers)

    {

    return 3*((numLayers-3)/2)*((numLayers-5)/2) + (numLayers<5 ? 0:1);

    }

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

  private int numCubitsPerEdge(int numLayers)

    {

    return numLayers<5 ? 0 : 2*(numLayers-4);

    }

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

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

    {

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

    }

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

// 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 ) mCorners = 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 = D/(0.5f*(numLayers-1));   // ?? maybe 0.5*

      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-5)/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 float[] computeCenter(int numLayers, int center, int part)

    {

    if( mCenterCoords==null ) initializeCenterCoords();

    if( mCorners     ==null ) mCorners = initializeCorners();

    if( mCenterMap   ==null ) mCenterMap = initializeCenterMap();

    int corner = mCenterMap[center][part];

    float[] cent = mCenterCoords[center];

    float[] corn = mCorners[corner];

    float D = numLayers/3.0f;

    float F = 1.0f - (2.0f*numLayers-6.0f)/(numLayers-1)*COS54*COS54;

    return new float[]

      {

        D * ( cent[0] + (corn[0]-cent[0])*F),

        D * ( cent[1] + (corn[1]-cent[1])*F),

        D * ( cent[2] + (corn[2]-cent[2])*F)

      };

    }

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

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

    {

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

    return part - 2*(part/4);

    }

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

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

    {

    if( mCenterCoords==null ) initializeCenterCoords();

    if( mCorners==null ) mCorners = initializeCorners();

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

    float D = numLayers/3.0f;

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

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

    int leftRight = 2*(part%2) -1;

    part /= 2;

    if( part==0 )

      {

      float T = 0.5f + leftRight/(numLayers-1.0f);

      float x = D * (T*c1[0]+(1.0f-T)*c2[0]);

      float y = D * (T*c1[1]+(1.0f-T)*c2[1]);

      float z = D * (T*c1[2]+(1.0f-T)*c2[2]);

      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 x = 0.5f * D * (c1[0]+c2[0]);

      float y = 0.5f * D * (c1[1]+c2[1]);

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

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

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

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

      float T = 0.5f + leftRight*(mult*SIN18 + 1.0f)/(numLayers-1);

      x = D * (T*c1[0]+(1.0f-T)*c2[0]);

      y = D * (T*c1[1]+(1.0f-T)*c2[1]);

      z = D * (T*c1[2]+(1.0f-T)*c2[2]);

      float H = mult*D*COS18/(numLayers-1);

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

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

      }

    }

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

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

    {

    if( mCorners==null ) mCorners = initializeCorners();

    int numL = numLayers[0];

    if( numL<5 ) return mCorners;

    int numCubitsPerCorner = numCubitsPerCorner(numL);

    int numCubitsPerEdge   = numCubitsPerEdge(numL);

    int numCubitsPerCenter = 5;

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

    int index=0;

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

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

      {

      computeBasicCornerVectors(corner);

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

        {

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

        }

      }

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

      {

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

        {

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

        }

      }

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

      {

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

        {

        positions[index] = computeCenter(numL,center, part);

        }

      }

    return positions;

    }

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

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

    {

    int numL = numLayers[0];

    int numCubitsPerCorner = numCubitsPerCorner(numL);

    int numCubitsPerEdge   = numCubitsPerEdge(numL);

    int q = getQuat(cubit,numCubitsPerCorner,numCubitsPerEdge);

    return mObjectQuats[q];

    }

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

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

    {

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

    if( mCenterMap==null ) mCenterMap = initializeCenterMap();

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

      }

    if( numCubitsPerCorner==0 )

      {

      return mQuatCornerIndices[cubit];

      }

    else

      {

      cubit -= (NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge);

      int numCubitsPerCenter = 5;

      int face = cubit/numCubitsPerCenter;

      int index= cubit%numCubitsPerCenter;

      int center=mCenterMap[face][index];

      return mQuatCornerIndices[center];

      }

    }

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

  private float[][] getVertices(int variant)

    {

    int[] numLayers = getNumLayers();

    int numVariants = getNumCubitVariants(numLayers);

    int numL        = numLayers[0];

    boolean small   = numL<=3;

    if( variant==0 && !small )

      {

      float width = numL/(numL-1.0f);

      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 tmpVal= numL/(numL-1.0f);

      float height= tmpVal*COS18;

      float width = tmpVal + (type/2)*tmpVal*SIN18;

      boolean left = (type%2)==0;

      float X = height*SIN_HALFD;

      float Y = height*SIN18/COS18;

      float Z = height*COS_HALFD;

      float[][] vertices =

        {

            {   0,   0   ,   0 },

            {   X,   Y   ,  -Z },

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

            {  -X,   Y   ,  -Z },

            {   0, -width,   0 },

            {   X, -width,  -Z },

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

            {  -X, -width,  -Z },

        };

      if( !left )

        {

        int len = vertices.length;

        for(int i=0; i<len; i++) vertices[i][1] = -vertices[i][1];

        }

      return vertices;

      }

    else

      {

      float width = (1+0.5f*(numL-3)*SIN18)*numL/(numL-1);

      float X = width*COS18*SIN_HALFD;

      float Y = width*SIN18;

      float Z = width*COS18*COS_HALFD;

      float H = width*(SIN54/COS54);

      float H3= H/COS_HALFD;

      float X3= H*SIN_HALFD;

      float Z3= H*COS_HALFD;

      float C = 1/(COS54*(float)Math.sqrt(2-2*SIN18));

      return new float[][]

        {

            {   0,   0  ,     0 },

            {   X,   Y  ,    -Z },

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

            {  -X,   Y  ,    -Z },

            {   0,-width,     0 },

            {  X3,-width,   -Z3 },

            {   0,-width,   -H3 },

            { -X3,-width,   -Z3 }

        };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    int[] numLayers = getNumLayers();

    int numVariants = getNumCubitVariants(numLayers);

    int numL        = numLayers[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}

      };

    if( (variant!=0 || numL<=3) && (variant<numVariants-1) && (variant%2)!=1 )

      {

      int tmp, len = indices.length;

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

        {

        tmp = indices[i][0];

        indices[i][0] = indices[i][3];

        indices[i][3] = tmp;

        tmp = indices[i][1];

        indices[i][1] = indices[i][2];

        indices[i][2] = tmp;

        }

      }

    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;

    int angle = 25;

    float R = 0.7f;

    float S = 0.5f;

    if( variant==0 && !small )

      {

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

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

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

      return new ObjectFaceShape(bands,indices,null);

      }

    if( variant<numVariants-1 )

      {

      int E  = small ? 1 : 0;

      int N0 = small ? 4 : 3;

      int N1 = small ? 3 : 2;

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

      float[][] bands = { {h1,angle,R,S,N0,E,E}, {0.001f,angle,R,S,N1,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

      int N = small ? 4 : 3;

      int E = small ? 1 : 0;

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

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

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

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    int[] numLayers = getNumLayers();

    int numVariants = getNumCubitVariants(numLayers);

    int numL        = numLayers[0];

    boolean small   = numL<=3;

    if( variant==0 && !small )

      {

      float A = (2*SQ3/3)*SIN54;

      float B = 0.4f;

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

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

      float[][] centers = { {0.0f, -(float)Math.sqrt(1-A*A)*B,-A*B} };

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

      }

    if( variant<numVariants-1 )

      {

      int type = variant-1;

      float tmpVal= numL/(numL-1.0f);

      float height= tmpVal*COS18;

      float width = tmpVal + (type/2)*tmpVal*SIN18;

      float Z = height*COS_HALFD;

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

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

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

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

      }

    else

      {

      float A = (2*SQ3/3)*SIN54;

      float B = 0.4f;

      float[][] corners = { {0.10f,0.30f},{0.05f,0.15f} };

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

      float[][] centers = { {0.0f, -(float)Math.sqrt(1-A*A)*B,-A*B} };

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

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

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    switch(numLayers[0])

      {

      case 3: return 1;

      case 5: return 4;

      }

    return 1;

    }

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

  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;

    }

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

// we override getStickerRadii() anyway

  public float getStickerRadius()

    {

    return 0.0f;

    }

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

  public float getStickerStroke()

    {

    float stroke = 0.25f;

    if( isInIconMode() )

      {

      int[] numLayers = getNumLayers();

      if( numLayers[0]>3 ) stroke*=1.5f;

      }

    return stroke;

    }

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

  public float[][][] getStickerAngles()

    {

    return null;

    }

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

  public String getShortName()

    {

    switch(getNumLayers()[0])

      {

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

      case 5: return ListObjects.KILO_5.name();

      }

    return ListObjects.KILO_3.name();

    }

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

  public String[][] getTutorials()

    {

    int[] numLayers = getNumLayers();

    switch(numLayers[0])

      {

      case 3: return new String[][] {

                          {"gb","grgGgUSxiQg","How to Solve the Kilominx","Z3"},

                          {"es","g6WMYjkCLok","Resolver Kilominx","Cuby"},

                          {"ru","gjaknjuZXPs","Киломинкс как собрать","CUBES WORLD"},

                          {"fr","F7z6LztN-7A","Résoudre le Kilominx","Twins Cuber"},

                          {"de","fcmJdpLfZwk","Megaminx 2x2 lösen","JamesKnopf"},

                          {"pl","tdWh8f8qpq4","Kilominx TUTORIAL PL","MrUK"},

                          {"kr","8-X4GhQnE5I","2X2 킬로밍크스 TUTORIAL","큐브놀이터"},

                          {"vn","eW7RLayPPmA","Tutorial N.11 - Kilominx","Duy Thích Rubik"},

                          {"tw","iDueAHkim4g","二階五魔方進階解法","不正常魔術方塊研究中心"},

                         };

      case 5: return new String[][] {

                          {"gb","VAnzC2SYVc4","How To Solve A Master Kilominx","Grizz Media"},

                          {"es","ozINTg-61Fs","Tutorial Master Kilominx","RubikArt"},

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

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

                          {"ru","YRXRdT2jCn8","Как собрать Мастер Киломинкс ч.3","Артем Мартиросов"},

                          {"fr","usMiWt44aqo","Résolution du Master Kilominx","Asthalis"},

                          {"pl","rdln0IG86_s","Master Kilominx TUTORIAL PL","MrUK"},

                          {"br","0nmaZf2-44M","Como resolver o Master Kilominx 1/3","Rafael Cinoto"},

                          {"br","SkR6RybAKHc","Como resolver o Master Kilominx 2/3","Rafael Cinoto"},

                          {"br","5C7J7Cb4a7Q","Como resolver o Master Kilominx 3/3","Rafael Cinoto"},

                          {"kr","dvy-GxCjm5c","마스터 킬로밍크스 배우기 1","vincentcube"},

                          {"kr","Jm0B12vNxsE","마스터 킬로밍크스 배우기 2","vincentcube"},

                          {"kr","H1I18FVpr6g","마스터 킬로밍크스 배우기 3","vincentcube"},

                          {"tw","nVrtIVu_avo","四階五魔方 教學","不正常魔術方塊研究中心"},

                         };

      }

    return null;

    }

}