Magic Cube

import org.distorted.library.type.Static3D;

import static org.distorted.objects.TwistyMinx.C2;

import static org.distorted.objects.TwistyMinx.LEN;

import static org.distorted.objects.TwistyMinx.SIN54;

import static org.distorted.objects.TwistyMinx.COS54;

import static org.distorted.objects.TwistyObject.SQ5;

class MovementMinx extends Movement

  static final float DIST3D = (float)Math.sqrt(0.625f+0.275f*SQ5);

  static final float DIST2D = (SIN54/COS54)/2;

  static final Static3D[] FACE_AXIS = new Static3D[]

         {

           new Static3D(    C2/LEN, SIN54/LEN,    0      ),

           new Static3D(    C2/LEN,-SIN54/LEN,    0      ),

           new Static3D(   -C2/LEN, SIN54/LEN,    0      ),

           new Static3D(   -C2/LEN,-SIN54/LEN,    0      ),

           new Static3D( 0        ,    C2/LEN, SIN54/LEN ),

           new Static3D( 0        ,    C2/LEN,-SIN54/LEN ),

           new Static3D( 0        ,   -C2/LEN, SIN54/LEN ),

           new Static3D( 0        ,   -C2/LEN,-SIN54/LEN ),

           new Static3D( SIN54/LEN,    0     ,    C2/LEN ),

           new Static3D( SIN54/LEN,    0     ,   -C2/LEN ),

           new Static3D(-SIN54/LEN,    0     ,    C2/LEN ),

           new Static3D(-SIN54/LEN,    0     ,   -C2/LEN )

         };

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

    super(TwistyMinx.ROT_AXIS, FACE_AXIS, DIST3D, DIST2D);

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

  public float returnRotationFactor(int numLayers, int row)

    {

    return 1.0f;

    }

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

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

    }

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

// 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 1,2,3,4,5 - the vertex of the pentagon to which point 'point' is the closest, if the

// 'point' is inside the pentagon - or 0 otherwise.

// The 'first' vertex is the one we meet the first when we rotate clockwise starting from 12:00.

// This vertex makes angle 'returnAngle()' with the line coming out upwards from the center of the

// pentagon.

// Distance from the center to a vertex of the pentagon = 1/(6*COS54)

  private int returnPartOfThePentagon(float[] point, int face)

    {

    float angle = returnAngle(face);

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

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

      {

      if( isOnTheLeft(point, DIST2D, (9-2*i)*A-angle) ) return 0;

      }

    if( isOnTheLeft(point, 0, 2.5f*A-angle) )

      {

      if( isOnTheLeft(point, 0, 3.5f*A-angle) )

        {

        return isOnTheLeft(point, 0, 5.5f*A-angle) ? 4 : 5;

        }

      else return 1;

      }

    else

      {

      if( isOnTheLeft(point, 0, 4.5f*A-angle) )

        {

        return 3;

        }

      else

        {

        return isOnTheLeft(point, 0, 6.5f*A-angle) ? 2 : 1;

        }

      }

    }

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

  boolean isInsideFace(int face, float[] p)

    {

    return returnPartOfThePentagon(p,face) > 0;

    }