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

import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;

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

public class TwistyMirrorPyraminx extends ShapeTetrahedron

{

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

  private static final float[] MIRROR_VEC = { 0.06f, 0.15f, 0.02f };

  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 TwistyMirrorPyraminx(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, 1.8f, 2.5f };

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

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      int nL = getNumLayers()[0];

      mEdges = new int[nL][];

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

        {

        int numEnabledMoves = 2*(nL-i);

        mEdges[i] = new int[4*2*numEnabledMoves];

        int index = 0;

        int startMove= 0;

        int offset = (i==nL-1 ? 2:0);  // if the last move was a tip, the only possible

                                       // next move is the second-to-largest layer.

        fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves);

        index += (2*numEnabledMoves);

        startMove += (2*nL);

        fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves);

        index += (2*numEnabledMoves);

        startMove += (2*nL);

        fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves);

        index += (2*numEnabledMoves);

        startMove += (2*nL);

        fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves);

        }

      }

    return mEdges;

    }

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

  private void fillEdge(int[] edge, int index, int move, int offset, int num)

    {

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

      {

      edge[index+2*i  ] = (move+offset);

      edge[index+2*i+1] = (i+offset)/2;

      move++;

      }

    }

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

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

    {

    if( mCuts==null )

      {

      float[] c = { SQ6/12, 5*SQ6/12 };

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

      }

    return mCuts;

    }

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

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

    {

    boolean[] tmp = {true,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/4 + 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]/3, d[1]/3, d[2]/3, d[3]/3 };

      }

    return mDist3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlTetrahedron.FACE_AXIS;

    }

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

  private void addTetrahedralLattice(int size, int index, float[][] pos)

    {

    final float DX = 1.0f;

    final float DY = SQ2/2;

    final float DZ = 1.0f;

    float startX = 0.0f;

    float startY =-DY*(size-1)/2;

    float startZ = DZ*(size-1)/2;

    for(int layer=0; layer<size; layer++)

      {

      float currX = startX;

      float currY = startY;

      for(int x=0; x<layer+1; x++)

        {

        float currZ = startZ;

        for(int z=0; z<size-layer; z++)

          {

          pos[index] = new float[] {currX,currY,currZ};

          index++;

          currZ -= DZ;

          }

        currX += DX;

        }

      startX-=DX/2;

      startY+=DY;

      startZ-=DZ/2;

      }

    }

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

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

      addTetrahedralLattice(3, 0,mPositions);

      addTetrahedralLattice(2,10,mPositions);

      for( float[] pos : mPositions )

        {

        pos[0] += X;

        pos[1] += Y;

        pos[2] += 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 = 3*4;

    mCutPlanes = new float[numPlanes][];

    Static3D[] faceAxis = getFaceAxis();

    float[] dist = getDist();

    int[] numLayers = getNumLayers();

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

    float cut0 = cuts[0][0];

    float cut1 = cuts[0][1];

    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(), cut0 };

      }

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

      {

      Static3D ax = ROT_AXIS[p-8];

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

      }

    }

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

  private float[] internalPoint(int variant)

    {

    float[][] pos = getPositions();

    float[] p = pos[variant];

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

    }

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

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

      {

      int N = 5;

      int E = 0;

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

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

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

      }

    }

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

  private float[][] computeVertexEffectCenter(int variant)

    {

    float A = variant<4 ? -0.5f : -1.0f;

    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[][] corners  = variant<10 ? 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.12f : 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.MPYR_3.name();

    }

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

  public String[][] getTutorials()

    {

    return null;

    }

}