TwistyPuzzleLib

import org.distorted.objectlib.objects.TwistyBandagedMegaminx;

    return new TwistyBandagedMegaminx( TwistyObject.MESH_NICE, mode, ShapeDodecahedron.DEFAULT_ROT, new Static3D(0,0,0), size, data, null );

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

// 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.TouchControl.TC_TETRAHEDRON;

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

import org.distorted.library.effect.EffectName;

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.bandaged.FactoryBandagedPyraminx;

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;

import org.distorted.objectlib.shape.ShapeDodecahedron;

import org.distorted.objectlib.shape.ShapeTetrahedron;

import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;

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

public class TwistyBandagedMegaminx extends TwistyDodecahedron

{

  public static final String OBJECT_NAME_MEGAMINX = "LOCAL_MEGAMINX";

  // TODO

  private static final int OCT_1 = 0;

  private static final int TET_1 = 1;

  private static final int OTHER = 2;

  private static final int NUM_TYPES = 2;  // OCT_1 and TET_1

  private int[] mCubitVariantMap;

  private int[] mTypeVariantMap;

  private ObjectShape[] mTmpShapes;

  private int mNumVariants;

  private float[][] mPosition;

  private ObjectSignature mSignature;

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

  private float[][] getPositions()

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    return mPosition;

    }

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

// TODO

  private int getType(float[] pos, int numLayers)

    {

    return OTHER;

    }

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

  private int getType(int variant)

    {

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

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

    return -1;

    }

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

  private void produceTmpShape(int variant)

    {

    float[][] positions = getPositions();

    int cubit,numCubits = positions.length;

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

      {

      if( mCubitVariantMap[cubit]==variant ) break;

      }

    if( cubit>=numCubits )

      {

      android.util.Log.e("D", "unknown variant: "+variant);

      }

    else

      {

      FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

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

      }

    }

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

  private float[][] getVertices(int variant)

    {

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

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

    return mTmpShapes[variant].getVertices();

    }

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

// 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 super.getScrambleAlgorithms();

    }

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

  @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 ObjectFaceShape getObjectFaceShape(int variant)

    {

    int type = getType(variant);

    FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

    if( type>=0 )

      {

      int[] numLayers = getNumLayers();

      boolean iconMode = isInIconMode();

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

      int numFaces = type==TET_1 ? 4:8;  // TODO

      int[] bandIndices= new int[numFaces];

      for(int i=0; i<numFaces; i++) bandIndices[i] = 1;

      return new ObjectFaceShape(bands,bandIndices,null);

      }

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

    }

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

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

    }

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

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

    {

    FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

    return factory.getElementQuat(numLayers,cubit);

    }

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

// TODO

  public int getNumCubitVariants(int[] numLayers)

    {

    if( mNumVariants==0 )

      {

      float[][] positions = getPositions();

      boolean T1=false;

      boolean O1=false;

      int numCubits = positions.length;

      mCubitVariantMap = new int[numCubits];

      mTypeVariantMap = new int[NUM_TYPES];

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

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

        {

        int type = getType(positions[cubit],numLayers[0]);

        switch (type)

          {

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

                      mCubitVariantMap[cubit] = mTypeVariantMap[TET_1];

                      break;

          case OCT_1: if (!O1) { O1 = true; mTypeVariantMap[OCT_1]=mNumVariants++; }

                      mCubitVariantMap[cubit] = mTypeVariantMap[OCT_1];

                      break;

          default   : mCubitVariantMap[cubit] = mNumVariants++;

          }

        }

      FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

      factory.prepare(mNumVariants,numLayers);

      }

    return mNumVariants;

    }

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

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

    {

    return getPositions();

    }

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

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

    {

    int size = numLayers[0];

    float dist = (size%2==0) ? 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.10f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.16f : 0.08f;

    }

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

  public float[][][] getStickerAngles()

    {

    return null;

    }

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

  public String getShortName()

    {

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

    int[] numLayers = getNumLayers();

    return "M"+numLayers[0]+"_"+mSignature.getString();

    }

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

// TODO

  public ObjectSignature getSignature()

    {

    if( mSignature==null )

      {

      int[] numLayers = getNumLayers();

      mSignature = new ObjectSignature(numLayers[0],mPosition);

      }

    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;

    }

}

      int num = numLayers[i];

      layerRotatable[i] = new boolean[num];

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

      layerRotatable[i][num/2] = false;