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

import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;

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

public class TwistyBandagedPyraminx extends ShapeTetrahedron

{

  public static final String OBJECT_NAME = "LOCAL_PYRAMINX";

  private static final Static3D[] ROT_AXIS = new Static3D[]

        {

                new Static3D(     0,-SQ3/3,-SQ6/3),

                new Static3D(     0,-SQ3/3, SQ6/3),

                new Static3D( SQ6/3, SQ3/3,     0),

                new Static3D(-SQ6/3, SQ3/3,     0),

        };

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

  private int[][] mBasicAngle;

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

  private float[][] getPositions()

    {

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

    return mPosition;

    }

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

  private int getType(float[] pos)

    {

    if( pos.length>3 ) return OTHER;

    int[] numLayers = getNumLayers();

    int variant = FactoryBandagedPyraminx.getElementVariant(numLayers[0],pos[1]);

    return variant==0 ? OCT_1 : TET_1;

    }

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

  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

      {

      FactoryBandagedPyraminx factory = FactoryBandagedPyraminx.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 TwistyBandagedPyraminx(int meshState, int iconMode, Static4D quat, Static3D move, float scale, InitData data, InitAssets asset)

    {

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

    }

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

// Computing scramble states of many a bandaged cubes 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 float[][] returnRotationFactor()

    {

    int numL= getNumLayers()[0];

    float[][] factor = new float[4][numL];

    for(int ax=0; ax<4; ax++)

      for(int la=0; la<numL; la++) factor[ax][la] = ((float)numL)/(numL-la);

    return factor;

    }

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

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

    FactoryBandagedPyraminx factory = FactoryBandagedPyraminx.getInstance();

    if( type>=0 )

      {

      boolean iconMode = isInIconMode();

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

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

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

      }

    FactoryBandagedPyraminx factory = FactoryBandagedPyraminx.getInstance();

    return factory.createVertexEffects(variant,round);

    }

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

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

    {

    return new Static4D(0,0,0,1);

    }

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

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

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

          }

        }

      FactoryBandagedPyraminx factory = FactoryBandagedPyraminx.getInstance();

      factory.prepare(mNumVariants,numLayers);

      }

    return mNumVariants;

    }

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

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

    {

    return getPositions();

    }

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

  public boolean[][] getLayerRotatable(int[] numLayers)

    {

    int numAxis = ROT_AXIS.length;

    int size = numLayers[0];

    boolean[][] layerRotatable = new boolean[numAxis][size];

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

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

    return layerRotatable;

    }

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

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

    {

    if( mCuts==null )

      {

      int numL = numLayers[0];

      mCuts = new float[4][numL-1];

      for(int i=0; i<numL-1; i++)

        {

        float cut = (1.0f+i-numL/4.0f)*(SQ6/3);

        mCuts[0][i] = cut;

        mCuts[1][i] = cut;

        mCuts[2][i] = cut;

        mCuts[3][i] = cut;

        }

      }

    return mCuts;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlTetrahedron.FACE_AXIS;

    }

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

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][] { {{1,2,3}},{{0,2,3}},{{0,1,3}},{{0,1,2}} };

    }

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

  public int getTouchControlType()

    {

    return TC_TETRAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

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

    {

    return mCubitVariantMap[cubit];

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlTetrahedron.D3D;

    }

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

  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 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 "P"+numLayers[0]+"_"+mSignature.getString();

    }

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

// TODO

  public ObjectSignature getSignature()

    {

    if( mSignature==null )

      {

      int[] numLayers = getNumLayers();

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

      }

    return mSignature;

    }

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

  public String getObjectName()

    {

    return OBJECT_NAME;

    }

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

  public String getInventor()

    {

    return "??";

    }

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

  public int getYearOfInvention()

    {

    return 0;

    }

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

  public int getComplexity()

    {

    return 4;

    }

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

  public String[][] getTutorials()

    {

    return null;

    }

}