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

import static org.distorted.objectlib.bandaged.BandagedObjectMegaminx.MEGA_D;

import static org.distorted.objectlib.bandaged.BandagedObjectMegaminx.SIN18;

import static org.distorted.objectlib.main.TwistyObject.SQ5;

import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.C2;

import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.LEN;

import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.SIN54;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.objects.TwistyDodecahedron;

import org.distorted.objectlib.touchcontrol.TouchControlDodecahedron;

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

public class FactoryBandagedMegaminx extends FactoryBandaged

  {

  private static FactoryBandagedMegaminx mThis;

  private int[][] mEdgeMap;

  private float[][] mCorners;

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

  private FactoryBandagedMegaminx()

    {

    }

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

  private float[][] genericGetCuts(int numLayers, float dist)

    {

    float[][] cuts = new float[6][numLayers-1];

    float D = numLayers* TouchControlDodecahedron.DIST3D;

    float X = 2*D/(2+SIN18);  // height of the 'upper' part of a dodecahedron, i.e. put it on a table,

                              // its height is then 2D, it has one 'lower' part of height X, one

                              // 'middle' part of height Y and one upper part of height X again.

    int num = (numLayers-1)/2;

    float G = X*dist/num;     // height of one Layer

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

      {

      float cut = -D + (i+0.85f)*G;  // 0.85? not fully correct; attempt to make it

                                     // easier to rotate the outer layers

      int j = 2*num-1-i;

      cuts[0][i] =  cut;

      cuts[0][j] = -cut;

      cuts[1][i] =  cut;

      cuts[1][j] = -cut;

      cuts[2][i] =  cut;

      cuts[2][j] = -cut;

      cuts[3][i] =  cut;

      cuts[3][j] = -cut;

      cuts[4][i] =  cut;

      cuts[4][j] = -cut;

      cuts[5][i] =  cut;

      cuts[5][j] = -cut;

      }

    return cuts;

    }

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

  public static FactoryBandagedMegaminx getInstance()

    {

    if( mThis==null ) mThis = new FactoryBandagedMegaminx();

    return mThis;

    }

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

  public float[][] getVertices(int variant)

    {

    return null;

    }

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

  public int[][] getIndices(int variant)

    {

    return null;

    }

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

// return:

// 0: (x,y,z) does not belong to edge corner0->corner1

// 1: it belongs and is closer to corner0

// 2: it belongs and is closer to corner1

  private int belongsToEdge(float[] corner0, float[] corner1, float x, float y, float z)

    {

    float MAXERR = 0.01f;

    float v0x = corner0[0] - x;

    float v0y = corner0[1] - y;

    float v0z = corner0[2] - z;

    float v1x = corner1[0] - x;

    float v1y = corner1[1] - y;

    float v1z = corner1[2] - z;

    float len0 = v0x*v0x + v0y*v0y + v0z*v0z;

    float len1 = v1x*v1x + v1y*v1y + v1z*v1z;

    if( v0x != 0 )

      {

      float A = v1x/v0x;

      float errY = v1y - A*v0y;

      float errZ = v1z - A*v0z;

      if( errY>-MAXERR && errY<MAXERR && errZ>-MAXERR && errZ<MAXERR ) return len0<len1 ? 1:2;

      else return 0;

      }

    else if( v0y != 0 )

      {

      float A = v1y/v0y;

      float errX = v1x - A*v0x;

      float errZ = v1z - A*v0z;

      if( errX>-MAXERR && errX<MAXERR && errZ>-MAXERR && errZ<MAXERR ) return len0<len1 ? 1:2;

      else return 0;

      }

    else if( v0z != 0 )

      {

      float A = v1z/v0z;

      float errX = v1x - A*v0x;

      float errY = v1y - A*v0y;

      if( errX>-MAXERR && errX<MAXERR && errY>-MAXERR && errY<MAXERR ) return len0<len1 ? 1:2;

      else return 0;

      }

    return 0;

    }

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

  public int getElementVariant(float x, float y, float z)

    {

    int size = mNumLayers[0];

    float CENT_DIST_SQ = TouchControlDodecahedron.DIST3D;

    float CORN_DIST_SQ = (18+6*SQ5)/16;

    float EDGE_DIST_SQ = (14+6*SQ5)/16;

    float EDHA_DIST_SQ = (15+6*SQ5)/16;

    float d = x*x + y*y + z*z;

    float MAXERR = 0.01f;

    switch(size)

      {

      case 2: return 0;

      case 3: float d3c = d/9 - CORN_DIST_SQ;

              float d3e = d/9 - EDGE_DIST_SQ;

              if( d3c<MAXERR && d3c>-MAXERR ) return 0;

              if( d3e<MAXERR && d3e>-MAXERR ) return 1;

              return 2;

      case 4: if( mCorners==null ) mCorners = TwistyDodecahedron.initializeCorners();

              if( mEdgeMap==null ) mEdgeMap = TwistyDodecahedron.initializeEdgeMap();

              float d4c = d/25 - CORN_DIST_SQ;

              float d4h = d/25 - EDHA_DIST_SQ;

              if( d4c<MAXERR && d4c>-MAXERR ) return 0;

              if( d4h<MAXERR && d4h>-MAXERR )

                {

                float xCorr = 9*x/25;  // mCorners has the coords assuming edge length is 3

                float yCorr = 9*y/25;  // here we have edge length = 5 - so correct for that

                float zCorr = 9*z/25;

                for(int[] edge : mEdgeMap)

                  {

                  float[] c0 = mCorners[edge[0]];

                  float[] c1 = mCorners[edge[1]];

                  int loc = belongsToEdge(c0, c1, xCorr, yCorr, zCorr);

                  if( loc!=0 ) return loc;

                  }

                return 1;

                }

              return 3;

      case 5: float dist = d/25;

              if( dist< CENT_DIST_SQ + MAXERR ) return 3;

              if( dist< EDGE_DIST_SQ - MAXERR ) return 2;

              if( dist< EDGE_DIST_SQ + MAXERR ) return 1;

              return 0;

      }

    return 0;

    }

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

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

    {

    int size = numLayers[0];

    if( (size%2)==1 ) return genericGetCuts(size  ,0.5f-MEGA_D);

    else              return genericGetCuts(size+1,0.5f);

    }

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

  public Static3D[] getNormals()

    {

    return TouchControlDodecahedron.FACE_AXIS;

    }

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

  public float[][] getRotAxis()

    {

    return new float[][]

            {

                    {    C2/LEN, SIN54/LEN,    0      },

                    {   -C2/LEN, SIN54/LEN,    0      },

                    { 0        ,    C2/LEN, SIN54/LEN },

                    { 0        ,   -C2/LEN, SIN54/LEN },

                    { SIN54/LEN,    0     ,    C2/LEN },

                    { SIN54/LEN,    0     ,   -C2/LEN }

            };

    }

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

  public float[] getDist3D()

    {

    final float d = TouchControlDodecahedron.DIST3D*mNumLayers[0];

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

    }

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

// all the 10 *distinct* edges of the dodecahedron

  public float[][] getDiameterAxis()

    {

    float A = (SQ5+1)/4;

    float B = (SQ5-1)/4;

    float C = 0.5f;

    return new float[][]

            {

              { A, B, C},

              { A, B,-C},

              { A,-B, C},

              { A,-B,-C},

              { B, C, A},

              { B, C,-A},

              { B,-C, A},

              { B,-C,-A},

              { C, A, B},

              { C, A,-B},

              { C,-A, B},

              { C,-A,-B},

            };

    }

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

  public int diameterMap(float diameter)

    {

    if( diameter>=5.49f ) return 11;

    if( diameter>1.1f && diameter<1.9f ) return 3;

    return (int)(2*diameter+0.01f);

    }

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

  public float[][] getBands(boolean iconMode)

    {

    float height= iconMode ? 0.001f : 0.04f;

    int[] angle = {68,56,50,43,39,35,32,30,28,26,25};

    float R     = 0.3f;

    float S     = 0.5f;

    int extraI  = 0;

    int extraV  = 0;

    int numVertA= mNumLayers[0]>=4 ? 4 : 5;

    int numVertI= mNumLayers[0]>=4 ? 2 : 3;

    return new float[][] { {  0.001f    ,angle[ 0],R,S,numVertI,extraV,extraI},

                           {height      ,angle[ 1],R,S,numVertA,extraV,extraI},

                           {height      ,angle[ 1],R,S,numVertA,extraV,extraI},

                           {height/ 1.5f,angle[ 2],R,S,numVertA,extraV,extraI},

                           {height/ 2.0f,angle[ 3],R,S,numVertA,extraV,extraI},

                           {height/ 2.5f,angle[ 4],R,S,numVertA,extraV,extraI},

                           {height/ 3.0f,angle[ 5],R,S,numVertA,extraV,extraI},

                           {height/ 3.5f,angle[ 6],R,S,numVertA,extraV,extraI},

                           {height/ 4.0f,angle[ 7],R,S,numVertA,extraV,extraI},

                           {height/ 4.5f,angle[ 8],R,S,numVertA,extraV,extraI},

                           {height/ 5.0f,angle[ 9],R,S,numVertA,extraV,extraI},

                           {height/ 5.5f,angle[10],R,S,numVertA,extraV,extraI}

                          };

    }

  }