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

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

import org.distorted.objectlib.main.TwistyObject;

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;

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

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

      }

    }

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

  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 dx, float dy, float dz)

    {

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

    float MAXERR = 0.01f;

    switch(mSize[0])

      {

      case 2: float x2_0 = 3.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.25f;

              float x4_1 = 2.50f;

              float x4_2 = 2.50f*(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 = 2.5f*(0.5f-MEGA_D)*COS18;

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

              float x5_4 = 2.5f*SIN54 - 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;

    }

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

  MeshBase createMesh(float[] pos, boolean round)

    {

    FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

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

    }

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

// PUBLIC API

  public BandagedObjectMegaminx(DistortedScreen screen)

    {

    super(screen,6);

    }

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

  public float getScreenRatio()

    {

    return 0.2f;

    }

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

  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 )

      {

      mSize[0] = x;

      mSize[1] = x;

      mSize[2] = x;

      mSize[3] = x;

      mMax = x;

      mNumCubits = numCubits(x);

      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;

    }

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

  public TwistyObject createObject(int mode, float size)

    {

    float[][] pos = getCubitPositions();

    InitData data = new InitData( mSize,pos);

    return null;//new TwistyBandagedMegaminx( TwistyObject.MESH_NICE, mode, ShapeDodecahedron.DEFAULT_ROT, new Static3D(0,0,0), size, data, null );

    }

}