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.main.TwistyObject.SQ5;

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

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

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

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

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.metadata.Metadata;

import org.distorted.objectlib.objects.TwistyBandagedMegaminx;

import org.distorted.objectlib.shape.ShapeDodecahedron;

import org.distorted.objectlib.touchcontrol.TouchControlDodecahedron;

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

public class BandagedObjectMegaminx extends BandagedObject

{

  public static final float MEGA_D = 0.04f;

  public static final float SIN18 = (SQ5-1)/4;

  public static final float COS18 = (float)(0.25f*Math.sqrt(10.0f+2.0f*SQ5));

  private static final int NUM_CORNERS = 20;

  private static final int NUM_CENTERS = 12;

  private static final int NUM_EDGES   = 30;

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

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

    {

    int numL = numLayers[0];

    int distL = numL;

    boolean megaminx = isMegaminx(numL);

    float dist = megaminx ? 0.5f-MEGA_D : 0.5f;

    if( (numL%2)==0 ) numL++;

    float[][] ret = new float[6][numL-1];

    float D = distL*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 = (numL-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;

      ret[0][i] =  cut;

      ret[0][j] = -cut;

      ret[1][i] =  cut;

      ret[1][j] = -cut;

      ret[2][i] =  cut;

      ret[2][j] = -cut;

      ret[3][i] =  cut;

      ret[3][j] = -cut;

      ret[4][i] =  cut;

      ret[4][j] = -cut;

      ret[5][i] =  cut;

      ret[5][j] = -cut;

      }

    return ret;

    }

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

// The pair (distance,angle) defines a point P in R^2 in polar coordinate system. Let V be the vector

// from the center of the coordinate system to P.

// Let P' be the point defined by polar (distance,angle+PI/2). Let Lh be the half-line starting at

// P' and going in the direction of V.

// Return true iff point 'point' lies on the left of Lh, i.e. when we rotate (using the center of

// the coordinate system as the center of rotation) 'point' and Lh in such a way that Lh points

// directly upwards, is 'point' on the left or the right of it?

  private boolean isOnTheLeft(float[] point, float distance, float angle)

    {

    float sin = (float)Math.sin(angle);

    float cos = (float)Math.cos(angle);

    float vx = point[0] + sin*distance;

    float vy = point[1] - cos*distance;

    return vx*sin < vy*cos;

    }

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

// return angle (in radians) that the line connecting the center C of the pentagonal face and the

// first vertex of the pentagon makes with a vertical line coming upwards from the center C.

  private float returnAngle(int face)

    {

    switch(face)

      {

      case  0:

      case  2:

      case  6:

      case  7: return 0.0f;

      case  1:

      case  3:

      case  4:

      case  5: return (float)(36*Math.PI/180);

      case  9:

      case 10: return (float)(54*Math.PI/180);

      case  8:

      case 11: return (float)(18*Math.PI/180);

      }

    return 0.0f;

    }

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

// i.e. one with a center - as opposed to 'kilominx'

  static boolean isMegaminx(int size)

    {

    return (size%2)==1;

    }

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

  static int numCubitsPerCornerMega(int numLayers)

    {

    return 3*((numLayers-1)/2)*((numLayers-3)/2) + 1;

    }

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

  static int numCubitsPerEdgeMega(int numLayers)

    {

    return numLayers-2;

    }

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

  static int numCubitsPerCornerKilo(int numLayers)

    {

    return 3*((numLayers-3)/2)*((numLayers-5)/2) + (numLayers<5 ? 0:1);

    }

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

  static int numCubitsPerEdgeKilo(int numLayers)

    {

    return numLayers<5 ? 0 : 2*(numLayers-4);

    }

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

  public static int numCubits(int size)

    {

    if( isMegaminx(size) )

      {

      int numCubitsPerCorner = numCubitsPerCornerMega(size);

      int numCubitsPerEdge   = numCubitsPerEdgeMega(size);

      return NUM_CORNERS*numCubitsPerCorner+NUM_EDGES*numCubitsPerEdge+NUM_CENTERS;

      }

    else

      {

      size++;

      if(size==3) return NUM_CORNERS;

      int numCubitsPerCorner = numCubitsPerCornerKilo(size);

      int numCubitsPerEdge   = numCubitsPerEdgeKilo(size);

      int numCubitsPerCenter = 5;

      return NUM_CORNERS*numCubitsPerCorner+NUM_EDGES*numCubitsPerEdge+NUM_CENTERS*numCubitsPerCenter;

      }

    }

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

  public static boolean isAdjacent(int size, float dx, float dy, float dz)

    {

    float len = dx*dx + dy*dy + dz*dz;

    float MAXERR = 0.01f;

    switch(size)

      {

      case 2: float x2_0 = 2.01f;

              return len<=x2_0*x2_0;

      case 3: float x3_0 = 1.51f*(SIN54/COS54);

              return len<=x3_0*x3_0;

      case 4: float x4_0 = 1.0f;

              float x4_1 = 2.00f;

              float x4_2 = 2.00f*(1+SIN18);

              float d4_0 = len-x4_0*x4_0;

              float d4_1 = len-x4_1*x4_1;

              float d4_2 = len-x4_2*x4_2;

              return ( (d4_0<MAXERR && d4_0>-MAXERR) ||

                       (d4_1<MAXERR && d4_1>-MAXERR) ||

                       (d4_2<MAXERR && d4_2>-MAXERR)  );

      case 5: float x5_0 = 2.5f*(0.5f-MEGA_D);

              float x5_1 = 2.5f*(0.5f+MEGA_D);

              float x5_2 = x5_0*COS18;

              float x5_3 = x5_1 + x5_0*SIN18;

              float x5_4 = 2.5f*SIN54/COS54 - x5_2;

              float d5_0 = len-x5_0*x5_0;

              float d5_1 = len-x5_1*x5_1;

              float d5_2 = len-x5_2*x5_2;

              float d5_3 = len-x5_3*x5_3;

              float d5_4 = len-x5_4*x5_4;

              return ( (d5_0<MAXERR && d5_0>-MAXERR) ||

                       (d5_1<MAXERR && d5_1>-MAXERR) ||

                       (d5_2<MAXERR && d5_2>-MAXERR) ||

                       (d5_3<MAXERR && d5_3>-MAXERR) ||

                       (d5_4<MAXERR && d5_4>-MAXERR)  );

      }

    return false;

    }

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

  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 }

      };

    }

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

  float[][][] getPositions()

    {

    FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

    return factory.getPositions(mSize);

    }

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

  float getDist2D()

    {

    return (SIN54/COS54)/2;

    }

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

  int[] getColors()

    {

    return ShapeDodecahedron.FACE_COLORS;

    }

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

  boolean isAdjacent(float x1, float y1, float z1, float x2, float y2, float z2 )

    {

    float dx = x1-x2;

    float dy = y1-y2;

    float dz = z1-z2;

    return isAdjacent(mSize[0],dx,dy,dz);

    }

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

  MeshBase createMesh(float[] pos, boolean round)

    {

    FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

    return factory.createMesh(pos,mSize,false,round);

    }

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

// PUBLIC API

  public BandagedObjectMegaminx(DistortedScreen screen, int minSize, int maxSize)

    {

    super(screen,minSize,maxSize);

    }

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

  public float getScreenRatio()

    {

    return 0.3f;

    }

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

  public float[] getDist3D()

    {

    float d = (float)Math.sqrt(0.625f+0.275f*SQ5);

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

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlDodecahedron.FACE_AXIS;

    }

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

  public boolean tryChangeObject(int x, int y, int z)

    {

    if( mSize[0]!=x && x>=mMinSize && x<=mMaxSize )

      {

      mSize[0] = x;

      mSize[1] = x;

      mSize[2] = x;

      mSize[3] = x;

      mSize[4] = x;

      mSize[5] = x;

      mMax = x;

      mNumCubits = numCubits(x);

      mCuts = getCuts(mSize);

      return true;

      }

    else if( mCuts==null )

      {

      mMax = 2;

      mNumCubits = numCubits(mMax);

      mCuts = getCuts(mSize);

      return true;

      }

    return false;

    }

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

  public int computeProjectionAngle()

    {

    return 60;

    }

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

  public boolean isInsideFace(int face, float[] p)

    {

    float angle = returnAngle(face);

    float A = (float)(Math.PI/5);

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

      {

      if( isOnTheLeft(p, mDist2D, (9-2*i)*A-angle) ) return false;

      }

    return true;

    }

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

  private int[] createLayers(int val)

    {

    int[] ret = new int[6];

    for(int i=0; i<6; i++) ret[i] = val;

    return ret;

    }

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

  public TwistyObject createObject(int mode, float size)

    {

    int param=-1;

    int[] numLayers = null;

    switch(mSize[0])

      {

      case 2: param = TwistyBandagedMegaminx.KILOMINX3; numLayers = createLayers(3); break;

      case 3: param = TwistyBandagedMegaminx.MEGAMINX3; numLayers = createLayers(3); break;

      case 4: param = TwistyBandagedMegaminx.KILOMINX5; numLayers = createLayers(5); break;

      case 5: param = TwistyBandagedMegaminx.MEGAMINX5; numLayers = createLayers(5); break;

      }

    float[][] pos = getCubitPositions();

    Metadata meta = new Metadata( null, numLayers,param,pos,0);

    return new TwistyBandagedMegaminx( mode, ShapeDodecahedron.DEFAULT_ROT, new Static3D(0,0,0), size, meta, null );

    }

}