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

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

import org.distorted.objectlib.shape.ShapeTetrahedron;

import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;

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

public class TwistyMirrorJing extends ShapeTetrahedron

{

  public 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 float JING_F = 0.48f;

  private static final int[] FACE_COLORS = new int[] { ShapeColors.COLOR_WHITE};

  private static final float[] MIRROR_VEC = { 0.06f, 0.07f, 0.08f };

  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 TwistyMirrorJing(int iconMode, Static4D quat, Static3D move, float scale, Metadata meta, InitAssets asset)

    {

    super(iconMode, meta.getNumLayers()[0], 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()

    {

    float[] f = { 1.4f, 2.0f };

    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 = new float[] { (JING_F-0.51f)*(SQ6/3) };

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

    }

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

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

      Static3D[] axis = getFaceAxis();

      mDist = new float[4];

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

        {

        Static3D ax = axis[a];

        float d = ax.get0()*DX + ax.get1()*DY + ax.get2()*DZ;

        mDist[a] = SQ6/6 + d;

        }

      }

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

      }

    return mDist3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlTetrahedron.FACE_AXIS;

    }

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

  private float[][] getPositions()

    {

    if( mPositions==null )

      {

      final float X = MIRROR_VEC[0];

      final float Y = MIRROR_VEC[1];

      final float Z = MIRROR_VEC[2];

      mPositions = new float[][]

        {

          { 0.000f +X, -SQ2/2 +Y,  1.000f +Z },

          { 0.000f +X, -SQ2/2 +Y, -1.000f +Z },

          {-1.000f +X,  SQ2/2 +Y,  0.000f +Z },

          { 1.000f +X,  SQ2/2 +Y,  0.000f +Z },

          { 0.000f +X, -SQ2/2 +Y,  0.000f +Z },

          {-0.500f +X, 0.000f +Y,  0.500f +Z },

          { 0.500f +X, 0.000f +Y,  0.500f +Z },

          {-0.500f +X, 0.000f +Y, -0.500f +Z },

          { 0.500f +X, 0.000f +Y, -0.500f +Z },

          { 0.000f +X,  SQ2/2 +Y,  0.000f +Z },

          { 0.000f +X,  SQ2/6 +Y,  1.0f/3 +Z },

          { 0.000f +X,  SQ2/6 +Y, -1.0f/3 +Z },

          {-1.0f/3 +X, -SQ2/6 +Y,  0.000f +Z },

          { 1.0f/3 +X, -SQ2/6 +Y,  0.000f +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 = 2*4;

    mCutPlanes = new float[numPlanes][];

    Static3D[] faceAxis = getFaceAxis();

    float[] dist = getDist();

    int[] numLayers = getNumLayers();

    float[][] cuts = getCuts(numLayers);

    float cut = cuts[0][0];

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

      {

      Static3D ax = faceAxis[p];

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

      }

    for(int p=4; p<8; p++)

      {

      Static3D ax = ROT_AXIS[p-4];

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

      }

    }

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

  private float[] internalPoint(int variant)

    {

    float[][] pos = getPositions();

    float[] position = pos[variant];

    float[] ret = new float[3];

    float A = 0.9f;

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

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

    ret[2] = A*position[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<4 )

      {

      int N = 5;

      int E = 1;

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

      float[][] bands = { {height,35,0.3f,0.5f,N,E,E}, {0.001f,35,0.3f,0.5f,N,E,E} };

      return new ObjectFaceShape(bands,indices,null);

      }

    else if( variant<10 )

      {

      int N = 5;

      int E = 0;

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

      float[][] bands = { {height,35,0.3f,0.5f,N,E,E}, {0.001f,35,0.3f,0.5f,N,E,E} };

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

      int N = 5;

      int E = 0;

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

      float[][] bands = { {height,35,0.3f,0.5f,N,E,E}, {0.001f,35,0.3f,0.5f,3,0,0} };

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  private float[][] computeVertexEffectCenter(int variant)

    {

    float A;

         if( variant< 4 ) A = -0.4f;

    else if( variant<10 ) A = -1.0f;

    else                  A = -0.9f;

    float[][] positions = getPositions();

    float[] p = positions[variant];

    return new float[][] {{ A*p[0], A*p[1], A*p[2] }};

    }

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

  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 S,R;

         if( variant< 4 ) { S = 0.05f; R=0.15f; }

    else if( variant<10 ) { S = 0.05f; R=0.10f; }

    else                  { S = 0.05f; R=0.15f; }

    float[][] corners = {{S,R}};

    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.06f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.10f : 0.05f;

    }

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

  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.MJIN_2.name();

    }

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

  public String[][] getTutorials()

    {

    return null;

    }

}