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

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

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.metadata.Metadata;

import org.distorted.objectlib.signature.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.scrambling.ObjectScrambler;

import org.distorted.objectlib.shape.ShapeOctahedron;

import org.distorted.objectlib.signature.ObjectSignatureDiamond;

import org.distorted.objectlib.touchcontrol.TouchControlOctahedron;

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

public class TwistyBandagedDiamond extends ShapeOctahedron

{

  public static final String OBJECT_NAME_DIAMOND = "LOCAL_DIAMOND";

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

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

        {

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

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

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

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

        };

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

  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 = getMetadata().getPos();

    return mPosition;

    }

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

  private int getType(float[] pos)

    {

    if( pos.length>3 ) return OTHER;

    boolean octa = FactoryBandagedOctahedron.isOctahedron(pos[1]);

    return octa ? 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

      {

      FactoryBandagedOctahedron factory = FactoryBandagedOctahedron.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 TwistyBandagedDiamond(int iconMode, Static4D quat, Static3D move, float scale, Metadata meta, InitAssets asset)

    {

    super(iconMode, meta.getNumLayers()[0], quat, move, scale, meta, 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 float[][] returnRotationFactor()

    {

    int numL = getNumLayers()[0];

    float[] f = new float[numL];

    for(int i=0; i<numL; i++) f[i] = 1.5f;

    return new float[][] { f,f,f,f };

    }

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

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

    {

    int type = getType(variant);

    FactoryBandagedOctahedron factory = FactoryBandagedOctahedron.getInstance();

    if( type>=0 )

      {

      int[] numLayers = getNumLayers();

      boolean iconMode = isInIconMode();

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

      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 = type==0 ? -0.06f : -0.08f;

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

      }

    FactoryBandagedOctahedron factory = FactoryBandagedOctahedron.getInstance();

    return factory.createVertexEffects(variant,round);

    }

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

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

    {

    float[] pos = mPosition[cubit];

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

    }

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

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

          }

        }

      FactoryBandagedOctahedron factory = FactoryBandagedOctahedron.getInstance();

      factory.prepare(mNumVariants,numLayers);

      }

    return mNumVariants;

    }

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

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

    {

    return getPositions();

    }

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

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

    {

    int numAxis = ROT_AXIS.length;

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

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

      {

      layerRotatable[i] = new boolean[numLayers[i]];

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

      }

    return layerRotatable;

    }

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

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

    {

    int numL = numLayers[0];

    if( numL<2 ) return null;

    if( mCuts==null )

      {

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

      float cut = (SQ6/6)*(2-numL);

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

        {

        mCuts[0][i] = cut;

        mCuts[1][i] = cut;

        mCuts[2][i] = cut;

        mCuts[3][i] = cut;

        cut += SQ6/3;

        }

      }

    return mCuts;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlOctahedron.FACE_AXIS;

    }

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

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

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

      };

    }

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

  public int getTouchControlType()

    {

    return TC_OCTAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

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

    {

    return mCubitVariantMap[cubit];

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlOctahedron.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.08f;

    }

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

  public float getStickerStroke()

    {

    float stroke = 0.095f;

    if( isInIconMode() )

      {

      int[] numLayers = getNumLayers();

      switch(numLayers[0])

        {

        case 2: stroke*=1.4f; break;

        case 3: stroke*=2.0f; break;

        case 4: stroke*=2.1f; break;

        default:stroke*=2.2f; break;

        }

      }

    return stroke;

    }

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

  public float[][][] getStickerAngles()

    {

    return null;

    }

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

  public String getShortName()

    {

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

    int[] numLayers = getNumLayers();

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

    }

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

  public ObjectSignature getSignature()

    {

    if( mSignature==null )

      {

      int[] numLayers = getNumLayers();

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

      }

    return mSignature;

    }

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

  public String getObjectName()

    {

    return OBJECT_NAME_DIAMOND;

    }

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

  public String getInventor()

    {

    return "??";

    }

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

  public int getYearOfInvention()

    {

    return 0;

    }

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

  public float getComplexity()

    {

    return 4;

    }

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

  public String[][] getTutorials()

    {

    return null;

    }

}