Magic Cube

      case 0:

      case 1: enabled[1]=1; enabled[2]=2; break;

      case 2:

      case 3: enabled[1]=0; enabled[2]=2; break;

      case 4:

      case 5: enabled[1]=0; enabled[2]=1; break;

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

  public float returnRotationFactor(int numLayers, int row)

    {

    return 1.0f;

    }

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

  boolean isInsideFace(int face, float[] p)

    {

    return ( p[0]<=DIST2D && p[0]>=-DIST2D && p[1]<=DIST2D && p[1]>=-DIST2D );

    }

import org.distorted.library.type.Static3D;

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

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

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

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

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

class MovementUltimate 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(TwistyUltimate.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;

    }

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

  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;

      }

    return 1;

    }

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

  boolean isInsideFace(int face, float[] p)

    {

    return returnPartOfThePentagon(p,face) > 0;

    }

      case  0: enabled[1] = 2; enabled[2] = 3; break;

      case  1: enabled[1] = 1; enabled[2] = 3; break;

      case  2: enabled[1] = 1; enabled[2] = 3; break;

      case  3: enabled[1] = 2; enabled[2] = 3; break;

      case  4: enabled[1] = 0; enabled[2] = 3; break;

      case  5: enabled[1] = 0; enabled[2] = 2; break;

      case  6: enabled[1] = 0; enabled[2] = 2; break;

      case  7: enabled[1] = 0; enabled[2] = 3; break;

      case  8: enabled[1] = 1; enabled[2] = 2; break;

      case  9: enabled[1] = 0; enabled[2] = 1; break;

      case 10: enabled[1] = 0; enabled[2] = 1; break;

      case 11: enabled[1] = 1; enabled[2] = 2; break;