TwistyPuzzleLib

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

// Copyright 2023 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.objects.TwistyMegaminx.MEGA_D;

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

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

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.bandaged.FactoryBandagedMegaminx;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

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.scrambling.ObjectScrambler;

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

public class TwistyBandagedMegaminx extends TwistyDodecahedron

{

  public static final int KILOMINX3 = 2; // don't change those values

  public static final int MEGAMINX3 = 3; // ( see ObjectSignature.areNeighboursMegaminx() )

  public static final int KILOMINX5 = 4; // ( and getShortName() here )

  public static final int MEGAMINX5 = 5;

  public static final String OBJECT_NAME_MEGAMINX = "LOCAL_MEGAMINX";

  public static final char MARKER = 'm'; // keep lowercase

  private static final Static4D QUAT = new Static4D(0,0,0,1);

  private static final float[] KILOMINX_CORNER = new float[] {0, 1.00f, 2*C2};

  private static final float[] MEGAMINX_CORNER = new float[] {0, 1.50f, 3*C2};

  private static final float[] MKILOMINX_CORNER= new float[] {0, 2.00f, 4*C2};

  private static final float[] GIGAMINX_CORNER = new float[] {0, 2.50f, 5*C2};

  private static final float[] MEGAMINX_EDGE   = new float[] {0, 0.00f, 3*C2};

  private static final float[] MKILOMINX_EDGE1 = new float[] {0, 1.00f, 4*C2};

  private static final float[] MKILOMINX_EDGE2 = new float[] {0,-1.00f, 4*C2};

  private static final float[] GIGAMINX_EDGE1  = new float[] {0, 0.00f, 5*C2};

  private static final float DB = (2.5f-MEGA_D)/10;

  private static final float XB = DB*5*SIN54;

  private static final float ZB = (1-DB)*5*C2 + DB*5*SIN54;

  private static final float[] GIGAMINX_EDGE2  = new float[] {XB, 0.00f, ZB };

  private static final float YC = (1.5f+6*C2+6*SIN54)/5;

  private static final float ZC = (3*C2+6*SIN54)/5;

  private static final float[] MEGAMINX_CENTER = new float[] {0, YC, ZC};

  private static final float[] MKILOMINX_CENTER= new float[] {0, 4*YC/3, 4*ZC/3};

  private static final float[] GIGAMINX_CENTER = new float[] {0, 5*YC/3, 5*ZC/3};

  private static final int KILO_CENT = 0;

  private static final int MEGA_CENT = 1;

  private static final int CORNER    = 2;

  private static final int KILO_EDGE1= 3;

  private static final int KILO_EDGE2= 4;

  private static final int MEGA_EDGE1= 5;

  private static final int MEGA_EDGE2= 6;

  private static final int OTHER     = 7;

  private static final int NUM_TYPES = 7;

  private int[] mCubitVariantMap;

  private int[] mTypeVariantMap;

  private boolean[] mIsNonStandard;

  private ObjectShape[] mTmpShapes;

  private int mNumVariants;

  private int[] mCorrectedNumLayers;

  private float[][] mPosition;

  private float[][] mOrigPosition;  // again problem with the (2,3,4,5) numLayersFormat vs the (3,3,5,5) format:

                                    // for FactoryBandagedMegaminx we have to keep the original, 'uncorrected' positions;

  private ObjectSignature mSignature;

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

  private float[][] correctPos(float corr, float[][] pos)

    {

    int numPos = pos.length;

    float[][] ret = new float[numPos][];

    for(int p=0; p<numPos; p++)

      {

      float[] po = pos[p];

      int len = po.length/3;

      ret[p] = new float[3*len];

      float[] re = ret[p];

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

        {

        re[3*i  ] = corr * po[3*i  ];

        re[3*i+1] = corr * po[3*i+1];

        re[3*i+2] = corr * po[3*i+2];

        }

      }

    return ret;

    }

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

  private void correctVerts(float corr, float[][] verts)

    {

    for(float[] ve : verts)

      {

      ve[0] *= corr;

      ve[1] *= corr;

      ve[2] *= corr;

      }

    }

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

  private float[][] getPositions()

    {

    if( mPosition==null )

      {

      InitData data = getInitData();

      mOrigPosition = data.getPos();

      int param = data.getParam();

      switch(param)

        {

        case KILOMINX3: mPosition = correctPos(1.50f,mOrigPosition); break;

        case KILOMINX5: mPosition = correctPos(1.25f,mOrigPosition); break;

        case MEGAMINX3:

        case MEGAMINX5: mPosition = mOrigPosition;

        }

      }

    return mPosition;

    }

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

// numLayers that we get here from BandagedObjectMegaminx are in the format (3,3,5,5) - i.e. one

// that agrees with the format in the previous TwistyKilominx/TwistyMegaminx classes (and in

// TwistyDodecahedron!). But FactoryBandagedMegaminx requires the unified (2,3,4,5) format -

// translate here.

  private int[] correctNumLayers(int param)

    {

    switch(param)

      {

      case KILOMINX3: return new int[] {2,2,2,2,2,2};

      case MEGAMINX3: return new int[] {3,3,3,3,3,3};

      case KILOMINX5: return new int[] {4,4,4,4,4,4};

      case MEGAMINX5: return new int[] {5,5,5,5,5,5};

      }

    return null;

    }

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

  private float[] figureOutCubitPos(int variant, int param)

    {

    if( mIsNonStandard[variant] )

      {

      int numCubits = mPosition.length;

      for(int cubit = 0; cubit<numCubits; cubit++)

        if( mCubitVariantMap[cubit]==variant ) return mOrigPosition[cubit];

      }

    else

      {

      // cubit is one of the 'standard' shapes. Here we have to statically return a position

      // because it may very well happen that a Kilominx' cubit 0 is not a CORNER but one of

      // the 'non-standard' shapes and the above procedure would return an improper pos!

      switch(param)

        {

        case KILOMINX3: return KILOMINX_CORNER;

        case MEGAMINX3: int type3 = getType(variant);

                        switch( type3 )

                          {

                          case  CORNER    : return MEGAMINX_CORNER;

                          case  MEGA_EDGE1: return MEGAMINX_EDGE;

                          case  MEGA_CENT : return MEGAMINX_CENTER;

                          default         : android.util.Log.e("D", "illegal type "+type3);

                          }

                        break;

        case KILOMINX5: int type4 = getType(variant);

                        switch( type4 )

                          {

                          case  CORNER    : return MKILOMINX_CORNER;

                          case  KILO_EDGE1: return MKILOMINX_EDGE1;

                          case  KILO_EDGE2: return MKILOMINX_EDGE2;

                          case  KILO_CENT : return MKILOMINX_CENTER;

                          default         : android.util.Log.e("D", "illegal type "+type4);

                          }

                        break;

        case MEGAMINX5: int type5 = getType(variant);

                        switch( type5 )

                          {

                          case  CORNER    : return GIGAMINX_CORNER;

                          case  MEGA_EDGE1: return GIGAMINX_EDGE1;

                          case  MEGA_EDGE2: return GIGAMINX_EDGE2;

                          case  MEGA_CENT : return GIGAMINX_CENTER;

                          default         : android.util.Log.e("D", "illegal type "+type5);

                          }

                        break;

        }

      }

    return null;

    }

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

  private void produceTmpShape(int variant)

    {

    InitData data = getInitData();

    int param = data.getParam();

    float[] pos = figureOutCubitPos(variant,param);

    FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

    mTmpShapes[variant] = factory.createIrregularShape(variant,pos);

    switch(param)

      {

      case KILOMINX3: correctVerts(1.50f,mTmpShapes[variant].getVertices()); break;

      case KILOMINX5: correctVerts(1.25f,mTmpShapes[variant].getVertices()); break;

      }

    }

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

// PUBLIC API

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

    {

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

    }

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

// Computing scramble states of many a bandaged objects takes way too long time and too much space.

// Return null here and turn to construction of scramble tables just-in-time (scrambleType=2)

  public int[][] getScrambleEdges()

    {

    return null;

    }

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

  @Override

  public int[][] getScrambleAlgorithms()

    {

    return null;

    }

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

  @Override

  public int getScrambleType()

    {

    return ObjectScrambler.SCRAMBLING_BANDAGED;

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( mTmpShapes==null ) mTmpShapes = new ObjectShape[mNumVariants];

    if( mTmpShapes[variant]==null ) produceTmpShape(variant);

    return mTmpShapes[variant];

    }

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

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

    {

    float[] pos = mOrigPosition[cubit];

    return pos.length>3 ? QUAT : FactoryBandagedMegaminx.getInstance().getCubitQuat(pos[0],pos[1],pos[2]);

    }

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

  private int getType(int variant)

    {

    for(int t=0; t<NUM_TYPES; t++)

      if( mTypeVariantMap[t]==variant ) return t;

    return -1;

    }

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

/*

  private float[][] getVertices(int variant)

    {

    if( mTmpShapes==null ) mTmpShapes = new ObjectShape[mNumVariants];

    if( mTmpShapes[variant]==null ) produceTmpShape(variant);

    return mTmpShapes[variant].getVertices();

    }

*/

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    int[] numLayers = getNumLayers();

    int size = numLayers[0];

    boolean round = (DistortedLibrary.fastCompilationTF() && size<5 && !isInIconMode());

/*

    int type = getType(variant);

    if( type>=0 )

      {

      float[][] vertices = getVertices(variant);

      int numV = vertices.length;

      float S = -0.04f;

      String name = EffectName.DEFORM.name();

      float[] reg = {0,0,0,0.15f};

      float[][] variables = new float[numV][];

      String[] names      = new String[numV];

      float[][] regions   = new float[numV][];

      boolean[] uses      = new boolean[numV];

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

        {

        float[] v    = vertices[i];

        variables[i] = new float[] { 0, S*v[0], S*v[1], S*v[2], 1 };

        names[i]     = name;

        regions[i]   = reg;

        uses[i]      = round;

        }

      return new ObjectVertexEffects(names,variables,vertices,regions,uses);

      }

   */

    FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

    return factory.createVertexEffects(variant,round);

    }

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

/*

  private int[] createBandIndices(int type)

    {

    int[] bandIndices = null;

    switch(type)

      {

      case MEGA_CENT : bandIndices = new int[] {1,0,0,0,0,0};

                       break;

      case KILO_EDGE1:

      case KILO_EDGE2:

      case MEGA_EDGE1:

      case MEGA_EDGE2: bandIndices = new int[] {1,1,0,0,0,0};

                       break;

      case KILO_CENT :

      case CORNER    : bandIndices = new int[] {1,1,1,0,0,0};

                       break;

      }

    return new int[] {0,0,0,0,0,0};//bandIndices;

    }

*/

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

/*

    int type = getType(variant);

    if( type>=0 )

      {

      int param = getInitData().getParam();

      int[] numLayers = correctNumLayers(param);

      if( numLayers!=null )

        {

        boolean iconMode = isInIconMode();

        float[][] bands = factory.getBands(iconMode,numLayers);

        int[] bandIndices = createBandIndices(type);

        return new ObjectFaceShape(bands, bandIndices, null);

        }

      }

*/

    return factory.createIrregularFaceShape(variant, isInIconMode() );

    }

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

  private int translateVariant(int size, int variant)

    {

    switch(size)

      {

      case 2: return KILO_CENT;

      case 3: return variant==0 ? CORNER : variant==1 ? MEGA_EDGE1 : MEGA_CENT;

      case 4: switch(variant)

                {

                case  0: return CORNER;

                case  1: return KILO_EDGE1;

                case  2: return KILO_EDGE2;

                default: return KILO_CENT;

                }

      case 5: switch(variant)

                {

                case  0: return CORNER;

                case  1: return MEGA_EDGE1;

                case  2: return MEGA_EDGE2;

                default: return MEGA_CENT;

                }

      }

    return -1;

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    if( mNumVariants==0 )

      {

      int param = getInitData().getParam();

      if( mCorrectedNumLayers==null ) mCorrectedNumLayers = correctNumLayers(param);

      int size = mCorrectedNumLayers==null ? -1 : mCorrectedNumLayers[0];

      float[][] positions = getPositions();

      boolean T0 = false;

      boolean T1 = false;

      boolean T2 = false;

      boolean T3 = false;

      boolean T4 = false;

      boolean T5 = false;

      boolean T6 = false;

      float corr=1.0f;

      if( size==2 ) corr=2.0f/3;

      else if( size==4 ) corr=4.0f/5;

      int numCubits = positions.length;

      mCubitVariantMap = new int[numCubits];

      mIsNonStandard = new boolean[numCubits];   // mNumVariants <= numCubits

      mTypeVariantMap = new int[NUM_TYPES];

      for(int i=0; i<NUM_TYPES; i++) mTypeVariantMap[i] = -1;

      FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

      for (int cubit=0; cubit<numCubits; cubit++)

        {

        int type = OTHER;

        float[] pos = positions[cubit];

        if( pos.length==3 )

          {

          int variant = factory.getElementVariant(mCorrectedNumLayers, corr*pos[0], corr*pos[1], corr*pos[2]);

          type = translateVariant(size, variant);

          }

        switch (type)

          {

          case KILO_CENT : if (!T0) { T0 = true; mTypeVariantMap[type]=mNumVariants++; }

                           mCubitVariantMap[cubit] = mTypeVariantMap[type];

                           break;

          case MEGA_CENT : if (!T1) { T1 = true; mTypeVariantMap[type]=mNumVariants++; }

                           mCubitVariantMap[cubit] = mTypeVariantMap[type];

                           break;

          case CORNER    : if (!T2) { T2 = true; mTypeVariantMap[type]=mNumVariants++; }

                           mCubitVariantMap[cubit] = mTypeVariantMap[type];

                           break;

          case KILO_EDGE1: if (!T3) { T3 = true; mTypeVariantMap[type]=mNumVariants++; }

                           mCubitVariantMap[cubit] = mTypeVariantMap[type];

                           break;

          case KILO_EDGE2: if (!T4) { T4 = true; mTypeVariantMap[type]=mNumVariants++; }

                           mCubitVariantMap[cubit] = mTypeVariantMap[type];

                           break;

          case MEGA_EDGE1: if (!T5) { T5 = true; mTypeVariantMap[type]=mNumVariants++; }

                           mCubitVariantMap[cubit] = mTypeVariantMap[type];

                           break;

          case MEGA_EDGE2: if (!T6) { T6 = true; mTypeVariantMap[type]=mNumVariants++; }

                           mCubitVariantMap[cubit] = mTypeVariantMap[type];

                           break;

          default        : mIsNonStandard[mNumVariants] = true;

                           mCubitVariantMap[cubit] = mNumVariants++;

          }

        }

      factory.prepare(mNumVariants,mCorrectedNumLayers);

      }

    return mNumVariants;

    }

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

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

    {

    return getPositions();

    }

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

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

    {

    int param = getInitData().getParam();

    int size = numLayers[0];

    float dist = (param==KILOMINX3 || param==KILOMINX5) ? 0.5f : 0.5f-MEGA_D;

    return genericGetCuts(size,dist);

    }

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

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

    {

    return mCubitVariantMap[cubit];

    }

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

  public float getStickerRadius()

    {

    return 0.18f;

    }

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

  public float getStickerStroke()

    {

    int param = getInitData().getParam();

    switch(param)

      {

      case KILOMINX3: return isInIconMode() ? 0.38f : 0.27f;

      case MEGAMINX3: return isInIconMode() ? 0.27f : 0.18f;

      case KILOMINX5: return isInIconMode() ? 0.38f : 0.26f;

      case MEGAMINX5: return isInIconMode() ? 0.40f : 0.18f;

      }

    return 0.0f;

    }

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

  public float[][][] getStickerAngles()

    {

    return null;

    }

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

  public String getShortName()

    {

    if( mSignature==null ) mSignature = getSignature();

    int param = getInitData().getParam();

    return MARKER+(param+"_"+mSignature.getString());

    }

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

  public ObjectSignature getSignature()

    {

    if( mSignature==null )

      {

      int param = getInitData().getParam();

      mSignature = new ObjectSignature(mPosition,param);

      }

    return mSignature;

    }

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

  public String getObjectName()

    {

    return OBJECT_NAME_MEGAMINX;

    }

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

  public String getInventor()

    {

    return "??";

    }

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

  public int getYearOfInvention()

    {

    return 0;

    }

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

  public int getComplexity()

    {

    return 4;

    }

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

  public String[][] getTutorials()

    {

    return null;

    }

}