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.bandaged.FactoryBandaged.QUAT;

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

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

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

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.metadata.Metadata;

import org.distorted.objectlib.scrambling.ObjectScrambler;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.signature.ObjectSignature;

import org.distorted.objectlib.signature.ObjectSignatureSkewb;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

public class TwistyBandagedSkewb extends ShapeHexahedron

{

  public static final String OBJECT_NAME_SKEWB = "LOCAL_SKEWB";

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

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

        {

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

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

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

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

        };

  private static final float[] CORNER2 = new float[] {1.0f,1.0f,1.0f};

  private static final float[] CENTER2 = new float[] {0.0f,0.0f,1.0f};

  private static final float[] CORNER3 = new float[] {1.5f,1.5f,1.5f};

  private static final float[] CENTER3 = new float[] {0.0f,0.0f,1.5f};

  private static final float[] EDGE3   = new float[] {0.0f,1.5f,1.5f};

  private static final int COR = 0;

  private static final int CEN = 1;

  private static final int EDG = 2;

  private static final int OTHER = 3;

  private static final int NUM_TYPES = 3;

  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 boolean[] mIsNonStandard;

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

  private float[][] getPositions()

    {

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

    return mPosition;

    }

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

  private int getType(int variant)

    {

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

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

    return -1;

    }

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

  private float[] figureOutCubitPos(int variant)

    {

    if( mIsNonStandard[variant] )

      {

      int numCubits = mPosition.length;

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

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

      }

    else // see TwistyBandagedMegaminx

      {

      int type = getType(variant);

      if(getNumLayers()[0]==2) return type==0 ? CORNER2 : CENTER2;

      else return type==0 ? CORNER3 : type==1 ? CENTER3 : EDGE3;

      }

    return null;

    }

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

  private void produceTmpShape(int variant)

    {

    float[] pos = figureOutCubitPos(variant);

    FactoryBandagedSkewb factory = FactoryBandagedSkewb.getInstance();

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

    }

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

  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 TwistyBandagedSkewb(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.7f;

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

    FactoryBandagedSkewb factory = FactoryBandagedSkewb.getInstance();

    if( type>=0 )

      {

      int[] numLayers = getNumLayers();

      boolean iconMode = isInIconMode();

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

      int[] bandIndices = null;

      switch(type)

        {

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

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

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

        }

      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!=1 ? -0.05f : 0.00f;

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

      }

    FactoryBandagedSkewb factory = FactoryBandagedSkewb.getInstance();

    return factory.createVertexEffects(variant,round);

    }

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

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

    {

    float[] pos = mPosition[cubit];

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

    }

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

  private int translateVariant(int variant)

    {

    return variant==0 ? COR : variant==1 ? CEN : EDG;

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    if( mNumVariants==0 )

      {

      float[][] positions = getPositions();

      boolean CO = false;

      boolean CE = false;

      boolean ED = false;

      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;

      FactoryBandagedSkewb factory = FactoryBandagedSkewb.getInstance();

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

        {

        int type = OTHER;

        float[] pos = positions[cubit];

        if( pos.length==3 )

          {

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

          type = translateVariant(variant);

          }

        switch (type)

          {

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

                     mCubitVariantMap[cubit] = mTypeVariantMap[type];

                     break;

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

                     mCubitVariantMap[cubit] = mTypeVariantMap[type];

                     break;

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

                     mCubitVariantMap[cubit] = mTypeVariantMap[type];

                     break;

          default  : mIsNonStandard[mNumVariants] = true;

                     mCubitVariantMap[cubit] = mNumVariants++;

          }

        }

      factory.prepare(mNumVariants,numLayers);

      }

    return mNumVariants;

    }

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

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

    {

    return getPositions();

    }

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

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

    {

    boolean[] tmp = numLayers[0]==2 ? (new boolean[] {true,true}) : (new boolean[] {true,false,true});

    return new boolean[][] {tmp,tmp,tmp,tmp};

    }

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

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

    {

    if( mCuts==null )

      {

      float[] c = numLayers[0]==2 ? (new float[] {0.0f}) : (new float[] {-SQ3/4, SQ3/4});

      mCuts = new float[][] {c,c,c,c};

      }

    return mCuts;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

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

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

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

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

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

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

      };

    }

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

  public int getTouchControlType()

    {

    return TC_HEXAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_SPLIT_CORNER;

    }

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

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

    {

    return mCubitVariantMap[cubit];

    }

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

  public float[] getDist3D(int[] numLayers)

    {

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

    if( isInIconMode() )

      {

      int[] numLayers = getNumLayers();

      stroke *= (numLayers[0]==2 ? 1.5f : 2.0f);

      }

    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 ObjectSignatureSkewb(numLayers[0],mPosition);

      }

    return mSignature;

    }

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

  public String getObjectName()

    {

    return OBJECT_NAME_SKEWB;

    }

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

  public String getInventor()

    {

    return "??";

    }

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

  public int getYearOfInvention()

    {

    return 0;

    }

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

  public float getComplexity()

    {

    return 4;

    }

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

  public String[][] getTutorials()

    {

    return null;

    }

}