TwistyPuzzleLib

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.objectlib.objects;

import static org.distorted.objectlib.main.Movement.MOVEMENT_SHAPECHANGE;

import static org.distorted.objectlib.main.Movement.TYPE_NOT_SPLIT;

import java.io.InputStream;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.main.MovementC;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSticker;

import org.distorted.objectlib.helpers.ScrambleState;

import org.distorted.objectlib.main.Twisty6;

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

public class TwistyCuboid extends Twisty6

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

  private ScrambleState[] mStates;

  private Static4D[] mQuats;

  private float[][] mCuts;

  private int[] mBasicAngle;

  private ObjectSticker[] mStickers;

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

  public TwistyCuboid(int[] numL, Static4D quat, Static3D move, InputStream stream)

    {

    super(numL, (numL[0]+numL[1]+numL[2])/3.0f, quat, move, stream);

    }

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

  private int[] createEdges(int size, boolean full, int vertex)

    {

    if( size==1 ) return null;

    if( full )

      {

      int[] ret = new int[9*size];

      for(int l=0; l<size; l++)

        {

        ret[9*l  ] = l;

        ret[9*l+1] =-1;

        ret[9*l+2] = vertex;

        ret[9*l+3] = l;

        ret[9*l+4] = 1;

        ret[9*l+5] = vertex;

        ret[9*l+6] = l;

        ret[9*l+7] = 2;

        ret[9*l+8] = vertex;

        }

      return ret;

      }

    else

      {

      int[] ret = new int[6*size];

      for(int l=0; l<size; l++)

        {

        ret[6*l  ] = l;

        ret[6*l+1] = 1;

        ret[6*l+2] = vertex;

        ret[6*l+3] = l;

        ret[6*l+4] =-1;

        ret[6*l+5] = vertex;

        }

      return ret;

      }

    }

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

  public ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int[] numLayers = getNumLayers();

      int X = numLayers[0];

      int Y = numLayers[1];

      int Z = numLayers[2];

      int[][] mX = new int[16][];

      int[][] mY = new int[16][];

      int[][] mZ = new int[16][];

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

        {

        mX[i] = createEdges(X,Y==Z,i);

        mY[i] = createEdges(Y,X==Z,i);

        mZ[i] = createEdges(Z,X==Y,i);

        }

      if( X>1 && Y>1 && Z>1 )

        {

        mStates = new ScrambleState[]

          {

          new ScrambleState( new int[][] { mX[ 1], mY[ 2], mZ[ 3] } ),  //  0 0

          new ScrambleState( new int[][] {   null, mY[ 4], mZ[ 5] } ),  //  1 x

          new ScrambleState( new int[][] { mX[ 6],   null, mZ[ 7] } ),  //  2 y

          new ScrambleState( new int[][] { mX[ 8], mY[ 9],   null } ),  //  3 z

          new ScrambleState( new int[][] { mX[10],   null, mZ[ 7] } ),  //  4 xy

          new ScrambleState( new int[][] { mX[11], mY[ 9],   null } ),  //  5 xz

          new ScrambleState( new int[][] {   null, mY[12], mZ[ 5] } ),  //  6 yx

          new ScrambleState( new int[][] { mX[ 8], mY[13],   null } ),  //  7 yz

          new ScrambleState( new int[][] {   null, mY[ 4], mZ[14] } ),  //  8 zx

          new ScrambleState( new int[][] { mX[ 6],   null, mZ[15] } ),  //  9 zy

          new ScrambleState( new int[][] {   null,   null, mZ[ 5] } ),  // 10 xyx

          new ScrambleState( new int[][] {   null, mY[ 4],   null } ),  // 11 xzx

          new ScrambleState( new int[][] {   null,   null, mZ[ 7] } ),  // 12 yxy

          new ScrambleState( new int[][] { mX[ 6],   null,   null } ),  // 13 yzy

          new ScrambleState( new int[][] {   null, mY[ 9],   null } ),  // 14 zxz

          new ScrambleState( new int[][] { mX[ 8],   null,   null } ),  // 15 zyz

          };

        }

      else if( X==1 && Y==1 && Z==1 )

        {

        int[] state = new int[] {0,-1,0,0,1,0,0,2,0};

        mStates = new ScrambleState[]

          {

          new ScrambleState( new int[][] { state, state, state } )

          };

        }

      else

        {

        mStates = new ScrambleState[]

          {

          new ScrambleState( new int[][] { mX[ 0], mY[ 0], mZ[ 0] } )

          };

        }

      }

    return mStates;

    }

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

  private void initializeQuats()

    {

    mQuats = new Static4D[]

         {

         new Static4D(  0.0f,   0.0f,   0.0f,   1.0f),

         new Static4D(  1.0f,   0.0f,   0.0f,   0.0f),

         new Static4D(  0.0f,   1.0f,   0.0f,   0.0f),

         new Static4D(  0.0f,   0.0f,   1.0f,   0.0f),

         new Static4D( SQ2/2,  SQ2/2,  0.0f ,   0.0f),

         new Static4D( SQ2/2, -SQ2/2,  0.0f ,   0.0f),

         new Static4D( SQ2/2,   0.0f,  SQ2/2,   0.0f),

         new Static4D(-SQ2/2,   0.0f,  SQ2/2,   0.0f),

         new Static4D( SQ2/2,   0.0f,   0.0f,  SQ2/2),

         new Static4D( SQ2/2,   0.0f,   0.0f, -SQ2/2),

         new Static4D(  0.0f,  SQ2/2,  SQ2/2,   0.0f),

         new Static4D(  0.0f,  SQ2/2, -SQ2/2,   0.0f),

         new Static4D(  0.0f,  SQ2/2,   0.0f,  SQ2/2),

         new Static4D(  0.0f,  SQ2/2,   0.0f, -SQ2/2),

         new Static4D(  0.0f,   0.0f,  SQ2/2,  SQ2/2),

         new Static4D(  0.0f,   0.0f,  SQ2/2, -SQ2/2),

         new Static4D(  0.5f,   0.5f,   0.5f,   0.5f),

         new Static4D(  0.5f,   0.5f,  -0.5f,   0.5f),

         new Static4D(  0.5f,   0.5f,  -0.5f,  -0.5f),

         new Static4D(  0.5f,  -0.5f,   0.5f,  -0.5f),

         new Static4D( -0.5f,  -0.5f,  -0.5f,   0.5f),

         new Static4D( -0.5f,   0.5f,  -0.5f,  -0.5f),

         new Static4D( -0.5f,   0.5f,   0.5f,  -0.5f),

         new Static4D( -0.5f,   0.5f,   0.5f,   0.5f)

         };

    }

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

  public int[] getSolvedQuats(int cubit, int[] numLayers)

    {

    if( mQuats ==null ) initializeQuats();

    int status = retCubitSolvedStatus(cubit,numLayers);

    return status<0 ? null : buildSolvedQuats(MovementC.FACE_AXIS[status], mQuats);

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    int extraI, extraV, num, numL = getNumLayers()[0];

    float height;

    switch(numL)

        {

        case 2 : num = 6; extraI = 2; extraV = 2; height = 0.045f; break;

        case 3 : num = 5; extraI = 2; extraV = 2; height = 0.045f; break;

        case 4 : num = 5; extraI = 1; extraV = 1; height = 0.045f; break;

        default: num = 5; extraI = 0; extraV = 0; height = 0.045f; break;

        }

    double[][] vertices = new double[][]

          {

              { 0.5, 0.5, 0.5 },

              { 0.5, 0.5,-0.5 },

              { 0.5,-0.5, 0.5 },

              { 0.5,-0.5,-0.5 },

              {-0.5, 0.5, 0.5 },

              {-0.5, 0.5,-0.5 },

              {-0.5,-0.5, 0.5 },

              {-0.5,-0.5,-0.5 },

          };

    int[][] vert_indices = new int[][]

          {

              {2,3,1,0},

              {7,6,4,5},

              {4,0,1,5},

              {7,3,2,6},

              {6,2,0,4},

              {3,7,5,1}

          };

    float[][] corners   = new float[][] { {0.036f,0.12f} };

    int[] cornerIndices = new int[] { 0,0,0,0,0,0,0,0 };

    float[][] centers   = new float[][] { {0.0f, 0.0f, 0.0f} };

    int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0 };

    if( variant==0 )

      {

      float[][] bands   = new float[][] { {height,35,0.5f,0.7f,num,extraI,extraV} };

      int[] bandIndices = new int[] { 0,0,0,0,0,0};

      return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);

      }

    else

      {

      int extraI2 = numL<=3 ? num-2 : 0;

      float[][] bands   = new float[][]

        {

          {height,35,0.5f,0.7f,num,extraI ,extraV},

          {height,35,0.5f,0.7f,  2,extraI2,     0},

          {height,35,0.5f,0.7f,  2,      0,     0},

        };

      int[] bandIndices = new int[] { 1,1,1,1,0,2};

      return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);

      }

    }

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

  private int getCenterNum(int cubit, int[] numLayers)

    {

    int num = cubit - getNumCornersAndEdges(numLayers);

    if( num>=0 )

      {

      int numLR = (numLayers[1]-2)*(numLayers[2]-2);

      if( num<  numLR ) return 0;

      if( num<2*numLR ) return 1;

      num -= 2*numLR;

      int numTD = (numLayers[0]-2)*(numLayers[2]-2);

      if( num<  numTD ) return 2;

      if( num<2*numTD ) return 3;

      num -= 2*numTD;

      int numFB = (numLayers[0]-2)*(numLayers[1]-2);

      if( num<  numFB ) return 4;

      if( num<2*numFB ) return 5;

      }

    return -1;

    }

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

  private int getNumCornersAndEdges(int[] numLayers)

    {

    int x = numLayers[0];

    int y = numLayers[1];

    int z = numLayers[2];

    return ( x==1 || y==1 || z==1 ) ? x*y*z : 4*( (x-2)+(y-2)+(z-2) ) + 8;

    }

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

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

    {

    final int X = numLayers[0];

    final int Y = numLayers[1];

    final int Z = numLayers[2];

    final float lenX = 0.5f*(X-1);

    final float lenY = 0.5f*(Y-1);

    final float lenZ = 0.5f*(Z-1);

    int curPos = 0;

    if( X==1 )

      {

      float[][] pos = new float[X*Y*Z][];

      for(int y=0; y<Y; y++)

        for(int z=0; z<Z; z++) pos[curPos++] = new float[] {+lenX,y-lenY,z-lenZ};

      return pos;

      }

    if( Y==1 )

      {

      float[][] pos = new float[X*Y*Z][];

      for(int x=0; x<X; x++)

        for(int z=0; z<Z; z++) pos[curPos++] = new float[] {x-lenX,+lenY,z-lenZ};

      return pos;

      }

    if( Z==1 )

      {

      float[][] pos = new float[X*Y*Z][];

      for(int x=0; x<X; x++)

        for(int y=0; y<Y; y++) pos[curPos++] = new float[] {x-lenX,y-lenY,+lenZ};

      return pos;

      }

    int numCubits = X*Y*Z - (X-2)*(Y-2)*(Z-2);

    float[][] pos = new float[numCubits][];

    pos[curPos++] = new float[] {-lenX,-lenY,-lenZ};

    pos[curPos++] = new float[] {-lenX,-lenY,+lenZ};

    pos[curPos++] = new float[] {-lenX,+lenY,-lenZ};

    pos[curPos++] = new float[] {-lenX,+lenY,+lenZ};

    pos[curPos++] = new float[] {+lenX,-lenY,-lenZ};

    pos[curPos++] = new float[] {+lenX,-lenY,+lenZ};

    pos[curPos++] = new float[] {+lenX,+lenY,-lenZ};

    pos[curPos++] = new float[] {+lenX,+lenY,+lenZ};

    for(int i=1; i<X-1; i++) pos[curPos++] = new float[] { i-lenX,  -lenY,  -lenZ };

    for(int i=1; i<X-1; i++) pos[curPos++] = new float[] { i-lenX,  -lenY,  +lenZ };

    for(int i=1; i<X-1; i++) pos[curPos++] = new float[] { i-lenX,  +lenY,  -lenZ };

    for(int i=1; i<X-1; i++) pos[curPos++] = new float[] { i-lenX,  +lenY,  +lenZ };

    for(int i=1; i<Y-1; i++) pos[curPos++] = new float[] {  -lenX, i-lenY,  -lenZ };

    for(int i=1; i<Y-1; i++) pos[curPos++] = new float[] {  -lenX, i-lenY,  +lenZ };

    for(int i=1; i<Y-1; i++) pos[curPos++] = new float[] {  +lenX, i-lenY,  -lenZ };

    for(int i=1; i<Y-1; i++) pos[curPos++] = new float[] {  +lenX, i-lenY,  +lenZ };

    for(int i=1; i<Z-1; i++) pos[curPos++] = new float[] {  -lenX,  -lenY, i-lenZ };

    for(int i=1; i<Z-1; i++) pos[curPos++] = new float[] {  -lenX,  +lenY, i-lenZ };

    for(int i=1; i<Z-1; i++) pos[curPos++] = new float[] {  +lenX,  -lenY, i-lenZ };

    for(int i=1; i<Z-1; i++) pos[curPos++] = new float[] {  +lenX,  +lenY, i-lenZ };

    for(int y=1; y<Y-1; y++)

      for(int z=1; z<Z-1; z++) pos[curPos++] = new float[] {+lenX,y-lenY,z-lenZ};

    for(int y=1; y<Y-1; y++)

      for(int z=1; z<Z-1; z++) pos[curPos++] = new float[] {-lenX,y-lenY,z-lenZ};

    for(int x=1; x<X-1; x++)

      for(int z=1; z<Z-1; z++) pos[curPos++] = new float[] {x-lenX,+lenY,z-lenZ};

    for(int x=1; x<X-1; x++)

      for(int z=1; z<Z-1; z++) pos[curPos++] = new float[] {x-lenX,-lenY,z-lenZ};

    for(int x=1; x<X-1; x++)

      for(int y=1; y<Y-1; y++) pos[curPos++] = new float[] {x-lenX,y-lenY,+lenZ};

    for(int x=1; x<X-1; x++)

      for(int y=1; y<Y-1; y++) pos[curPos++] = new float[] {x-lenX,y-lenY,-lenZ};

    return pos;

    }

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

  public Static4D getQuat(int cubit, int[] numLayers)

    {

    if( mQuats ==null ) initializeQuats();

    int centerNum = getCenterNum(cubit,numLayers);

    switch(centerNum)

      {

      case 0 : return mQuats[13];

      case 1 : return mQuats[12];

      case 2 : return mQuats[ 8];

      case 3 : return mQuats[ 9];

      case 4 : return mQuats[ 0];

      case 5 : return mQuats[ 1];

      default: return mQuats[ 0];

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return numLayers[0]>2 ? 2:1;

    }

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

  public int getCubitVariant(int cubit, int[] numLayers)

    {

    return cubit < getNumCornersAndEdges(numLayers) ? 0 : 1;

    }

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

  public int getVariantFaceColor(int variant, int face, int[] numLayers)

    {

    return 0;

    }

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

  public int getCubitFaceColor(int cubit, int face, int[] numLayers)

    {

    int centerNum = getCenterNum(cubit,numLayers);

    if( centerNum<0 )

      {

      int axis = face/2;

      return CUBITS[cubit].getRotRow(axis) == (face%2==0 ? (1<<(numLayers[axis]-1)):1) ? face : -1;

      }

    else

      {

      return face==4 ? centerNum : -1;

      }

    }

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

  public ObjectSticker retSticker(int sticker)

    {

    if( mStickers==null )

      {

      final float[][] STICKERS = new float[][]  { { -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f } };

      final float radius = 0.10f;

      final float[] radii = {radius,radius,radius,radius};

      mStickers = new ObjectSticker[STICKERS.length];

      float stroke = 0.08f;

      if( ObjectControl.isInIconMode() )

        {

        int[] numLayers = getNumLayers();

        switch(numLayers[0])

          {

          case 2: stroke*=1.8f; break;

          case 3: stroke*=2.0f; break;

          case 4: stroke*=2.1f; break;

          default:stroke*=2.2f; break;

          }

        }

      mStickers[0] = new ObjectSticker(STICKERS[0],null,radii,stroke );

      }

    return mStickers[sticker];

    }

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

  public Static4D[] getQuats()

    {

    if( mQuats ==null ) initializeQuats();

    return mQuats;

    }

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

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

    {

    if( mCuts==null )

      {

      mCuts = new float[3][];

      for(int axis=0; axis<3; axis++)

        {

        int len = numLayers[axis];

        float start = (2-len)*0.5f;

        if( len>=2 )

          {

          mCuts[axis] = new float[len-1];

          for(int i=0; i<len-1; i++) mCuts[axis][i] = start+i;

          }

        }

      }

    return mCuts;

    }

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

  public boolean[][] getLayerRotatable(int[] numLayers)

    {

    int numAxis = ROT_AXIS.length;

    boolean[][] layerRotatable = new boolean[numAxis][];

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

      {

      layerRotatable[i] = new boolean[numLayers[i]];

      for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;

      }

    return layerRotatable;

    }

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

  public int getMovementType()

    {

    return MOVEMENT_SHAPECHANGE;

    }

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

  public int getMovementSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

          {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}},

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    float avg = (numLayers[0]+numLayers[1]+numLayers[2])/3.0f;

    return new float[]

        {

        0.5f*numLayers[0]/avg,

        0.5f*numLayers[0]/avg,

        0.5f*numLayers[1]/avg,

        0.5f*numLayers[1]/avg,

        0.5f*numLayers[2]/avg,

        0.5f*numLayers[2]/avg,

        };

    }

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

  public int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  public int getNumStickerTypes(int[] numLayers)

    {

    return 1;

    }

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

  public int getNumCubitFaces()

    {

    return 6;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[] getBasicAngle()

    {

    if( mBasicAngle==null )

      {

      int[] num = getNumLayers();

      int x = num[1]==num[2] ? 4 : 2;

      int y = num[0]==num[2] ? 4 : 2;

      int z = num[0]==num[1] ? 4 : 2;

      mBasicAngle = new int[] { x,y,z };

      }

    return mBasicAngle;

    }

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

  public ObjectType intGetObjectType(int[] numLayers)

    {

    int x = numLayers[0];

    int y = numLayers[1];

    switch(x)

      {

      case 2: switch(y)

                {

                case 2: return ObjectType.CUBE_2;

                case 3: return ObjectType.CU_232;

                }

      case 3: switch(y)

                {

                case 2: return ObjectType.CU_323;

                case 3: return ObjectType.CUBE_3;

                case 4: return ObjectType.CU_343;

                }

      case 4: return ObjectType.CUBE_4;

      case 5: return ObjectType.CUBE_5;

      }

    return ObjectType.CUBE_3;

    }

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

  public String getObjectName()

    {

    switch(getNumLayers()[0])

      {

      case 2: return "Pocket Cube";

      case 3: return "Rubik Cube";

      case 4: return "Rubik's Revenge";

      case 5: return "Professor's Cube";

      }

    return "Rubik Cube";

    }

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

  public String getInventor()

    {

    switch(getNumLayers()[0])

      {

      case 2: return "Larry Nichols";

      case 3: return "Ernő Rubik";

      case 4: return "Péter Sebestény";

      case 5: return "Udo Krell";

      }

    return "Ernő Rubik";

    }

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

  public int getYearOfInvention()

    {

    switch(getNumLayers()[0])

      {

      case 2: return 1970;

      case 3: return 1974;

      case 4: return 1981;

      case 5: return 1981;

      }

    return 1974;

    }

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