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

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

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.FactoryShape;

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

import org.distorted.objectlib.metadata.Metadata;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

public class TwistyMirrorSkewb extends ShapeHexahedron

{

  public static final Static3D[] ROT_AXIS =

         {

           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 int[] FACE_COLORS = new int[] { COLOR_WHITE };

  private static final float[] MIRROR_VEC = { 0.10f, 0.15f, 0.20f };

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPositions;

  private ObjectShape[] mShapes;

  private float[][] mCutPlanes;

  private float[] mDist3D, mDist;

  private float[][] mPotentialVertices;

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

  public TwistyMirrorSkewb(int iconMode, Static4D quat, Static3D move, float scale, Metadata meta, InitAssets asset)

    {

    super(iconMode, 2*meta.getNumLayers()[0]-2, quat, move, scale, meta, asset);

    }

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

// here we cannot automatically detect the outer monochromatic walls -> use the old way.

  @Override

  public int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  @Override

  public int[][] getSolvedQuats()

    {

    return getOldSolvedQuats();

    }

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

  @Override

  public int getInternalColor()

    {

    return 0xff333333;

    }

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

  @Override

  public int[] getColorTable()

    {

    return FACE_COLORS;

    }

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

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

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null ) mEdges = ScrambleEdgeGenerator.getScrambleEdgesSingle(mBasicAngle);

    return mEdges;

    }

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

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

    {

    if( mCuts==null )

      {

      float[] c = {0};

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

      }

    return mCuts;

    }

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

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

    {

    boolean[] tmp = {true,true};

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

    }

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

  public int getTouchControlType()

    {

    return TC_CHANGING_SHAPEMOD;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return null;

    }

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

// 'full' dists (not divided by numLayers)

  private float[] getDist()

    {

    if( mDist==null )

      {

      float DX = MIRROR_VEC[0];

      float DY = MIRROR_VEC[1];

      float DZ = MIRROR_VEC[2];

      mDist = new float[] { 1+DX, 1-DX, 1+DY, 1-DY, 1+DZ, 1-DZ };

      }

    return mDist;

    }

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

// 'regular' dists for the touchControl (have to be divided by numLayers)

  public float[] getDist3D(int[] numLayers)

    {

    if( mDist3D==null )

      {

      float[] d = getDist();

      mDist3D = new float[] { d[0]/2, d[1]/2, d[2]/2, d[3]/2, d[4]/2, d[5]/2 };

      }

    return mDist3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

  private float[][] getPositions()

    {

    if( mPositions==null )

      {

      final float COR = 1.0f;

      final float CEN = 1.0f;

      final float X = MIRROR_VEC[0];

      final float Y = MIRROR_VEC[1];

      final float Z = MIRROR_VEC[2];

      mPositions = new float[8+6][];

      mPositions[0] = new float[]{ COR+X,  COR+Y,  COR+Z };

      mPositions[1] = new float[]{ COR+X,  COR+Y, -COR+Z };

      mPositions[2] = new float[]{ COR+X, -COR+Y,  COR+Z };

      mPositions[3] = new float[]{ COR+X, -COR+Y, -COR+Z };

      mPositions[4] = new float[]{-COR+X,  COR+Y,  COR+Z };

      mPositions[5] = new float[]{-COR+X,  COR+Y, -COR+Z };

      mPositions[6] = new float[]{-COR+X, -COR+Y,  COR+Z };

      mPositions[7] = new float[]{-COR+X, -COR+Y, -COR+Z };

      mPositions[ 8] = new float[]{     X,     Y, CEN+Z };

      mPositions[ 9] = new float[]{     X,     Y,-CEN+Z };

      mPositions[10] = new float[]{     X, CEN+Y,     Z };

      mPositions[11] = new float[]{     X,-CEN+Y,     Z };

      mPositions[12] = new float[]{ CEN+X,     Y,     Z };

      mPositions[13] = new float[]{-CEN+X,     Y,     Z };

      }

    return mPositions;

    }

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

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

    {

    return getPositions();

    }

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

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

    {

    return mObjectQuats[0];

    }

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

  private void createCutPlanes()

    {

    int numPlanes = 6+4;

    mCutPlanes = new float[numPlanes][];

    Static3D[] faceAxis = getFaceAxis();

    float[] dist = getDist();

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

      {

      Static3D ax = faceAxis[p];

      mCutPlanes[p] = new float[] { ax.get0(), ax.get1(), ax.get2(), dist[p] };

      }

    for(int p=6; p<10; p++)

      {

      Static3D ax = ROT_AXIS[p-6];

      mCutPlanes[p] = new float[] { ax.get0(), ax.get1(), ax.get2(), 0 };

      }

    }

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

  private float[] internalPoint(int variant)

    {

    float[][] pos = getPositions();

    float[] position = pos[variant];

    float[][] center = computeVertexEffectCenter(variant);

    float[] cent = center[0];

    float[] ret = new float[3];

    float A = 0.1f;

    ret[0] = position[0] + A*cent[0];

    ret[1] = position[1] + A*cent[1];

    ret[2] = position[2] + A*cent[2];

    return ret;

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( mShapes==null )

      {

      int[] numLayers = getNumLayers();

      int numV = getNumCubitVariants(numLayers);

      mShapes = new ObjectShape[numV];

      createCutPlanes();

      mPotentialVertices = FactoryShape.computePotentialVertices(mCutPlanes);

      }

    if( mShapes[variant]==null )

      {

      float[][] pos = getPositions();

      float[] point = internalPoint(variant);

      mShapes[variant] = FactoryShape.createShape(mCutPlanes,mPotentialVertices,pos[variant],point);

      }

    return mShapes[variant];

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    ObjectShape shape = getObjectShape(variant);

    int[][] ind    = shape.getVertIndices();

    float[][] vert = shape.getVertices();

    float[][] pos  = getPositions();

    int[] indices  = FactoryShape.produceBandIndices(vert, pos[variant], ind, getFaceAxis(), getDist() );

    if( variant<8 )

      {

      int N = 5;

      int E = 2;

      float height = isInIconMode() ? 0.001f : 0.04f;

      float[][] bands = { {height,35,0.16f,0.7f,N,E,E}, {0.001f, 35,1.00f,0.0f,N,E,E} };

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

      int N = 5;

      int E = 1;

      float height = isInIconMode() ? 0.001f : 0.05f;

      float[][] bands = { {height,35,SQ2/8,0.9f,N,E,E}, {0.001f,35,1,0.0f,3,0,0} };

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  private float[][] computeVertexEffectCenter(int variant)

    {

    final float A = 1.0f;

    switch(variant)

      {

      case  0: return new float[][] { {-A,-A,-A} };

      case  1: return new float[][] { {-A,-A, A} };

      case  2: return new float[][] { {-A, A,-A} };

      case  3: return new float[][] { {-A, A, A} };

      case  4: return new float[][] { { A,-A,-A} };

      case  5: return new float[][] { { A,-A, A} };

      case  6: return new float[][] { { A, A,-A} };

      case  7: return new float[][] { { A, A, A} };

      case  8: return new float[][] { { 0, 0,-A} };

      case  9: return new float[][] { { 0, 0, A} };

      case 10: return new float[][] { { 0,-A, 0} };

      case 11: return new float[][] { { 0, A, 0} };

      case 12: return new float[][] { {-A, 0, 0} };

      case 13: return new float[][] { { A, 0, 0} };

      }

    return null;

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    ObjectShape shape  = getObjectShape(variant);

    float[][] vertices = shape.getVertices();

    float[][] centers  = computeVertexEffectCenter(variant);

    float[][] pos      = getPositions();

    int[] indices      = FactoryShape.computeVertexEffectsIndices(vertices, pos[variant], getFaceAxis(), getDist() );

    float[][] corners  = variant<8 ? new float[][]{{0.03f, 0.20f}} : new float[][]{{0.03f, 0.15f}};

    return FactoryCubit.generateVertexEffect(vertices,corners,indices,centers,indices);

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 14;

    }

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

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

    {

    return cubit;

    }

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

  public float getStickerRadius()

    {

    return 0.08f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.16f : 0.08f;

    }

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

  public float[][][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  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 String getShortName()

    {

    return ListObjects.MSKE_2.name();

    }

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

  public String[][] getTutorials()

    {

    return null;

    }

}