TwistyPuzzleLib

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

// Copyright 2020 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.touchcontrol.TouchControl.TYPE_SPLIT_CORNER;

import static org.distorted.objectlib.touchcontrol.TouchControl.TC_HEXAHEDRON;

import java.io.InputStream;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

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

public class TwistyIvy extends ShapeHexahedron

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(+SQ3/3,+SQ3/3,+SQ3/3),

           new Static3D(+SQ3/3,+SQ3/3,-SQ3/3),

           new Static3D(+SQ3/3,-SQ3/3,+SQ3/3),

           new Static3D(+SQ3/3,-SQ3/3,-SQ3/3)

         };

  private static final int NUM_STICKERS = 2;

  public static final float IVY_D = 0.006f;

  private static final int  IVY_N = 8;

  private ScrambleState[] mStates;

  private int[] mBasicAngle;

  private Static4D[] mQuats;

  private float[][] mCuts;

  private int[][] mFaceMap;

  private ObjectSticker[] mStickers;

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

  public TwistyIvy(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(numL, numL[0], quat, move, scale, stream);

    }

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

  public ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int[] tmp = {0,-1,0, 0,1,0, 1,-1,0, 1,1,0 };

      mStates = new ScrambleState[]

        {

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

        };

      }

    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(  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(TouchControlHexahedron.FACE_AXIS[status],mQuats);

    }

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

  public Static4D[] getQuats()

    {

    if( mQuats==null ) initializeQuats();

    return mQuats;

    }

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

  public int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  public int getNumStickerTypes(int[] numLayers)

    {

    return NUM_STICKERS;

    }

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

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

    {

    if( mCuts==null )

      {

      float[] cut = new float[] {0.0f};

      mCuts = new float[][] { cut,cut,cut,cut };

      }

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

    }

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

  public int getMovementSplit()

    {

    return TYPE_SPLIT_CORNER;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

          {{0},{3},{3},{0}},

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

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

          {{1},{3},{3},{1}},

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

          {{2},{2},{3},{3}},

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return null;

    }

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

  public int getNumCubitFaces()

    {

    return 6;

    }

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

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

    {

    final float DIST_CORNER = numLayers[0]-1;

    final float DIST_CENTER = numLayers[0]-1;

    final float[][] CENTERS = new float[10][];

    CENTERS[0] = new float[] { DIST_CORNER, DIST_CORNER, DIST_CORNER };

    CENTERS[1] = new float[] {-DIST_CORNER, DIST_CORNER,-DIST_CORNER };

    CENTERS[2] = new float[] {-DIST_CORNER,-DIST_CORNER, DIST_CORNER };

    CENTERS[3] = new float[] { DIST_CORNER,-DIST_CORNER,-DIST_CORNER };

    CENTERS[4] = new float[] { DIST_CENTER,           0,           0 };

    CENTERS[5] = new float[] {-DIST_CENTER,           0,           0 };

    CENTERS[6] = new float[] {           0, DIST_CENTER,           0 };

    CENTERS[7] = new float[] {           0,-DIST_CENTER,           0 };

    CENTERS[8] = new float[] {           0,           0, DIST_CENTER };

    CENTERS[9] = new float[] {           0,           0,-DIST_CENTER };

    return CENTERS;

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      final float angle = (float)Math.PI/(2*IVY_N);

      final float CORR  = 1.0f - 2*IVY_D;

      float[][] centers= new float[][] { {-1.0f,-1.0f,-1.0f} };

      float[][] corners= new float[][] { {0.05f,0.20f}, {0.04f,0.20f} };

      int[] cornerIndices= new int[3*(IVY_N+1)+4];

      int[] centerIndices= new int[3*(IVY_N+1)+4];

      double[][] vertices= new double[3*(IVY_N+1)+4][3];

      int[][] vertIndices= new int[6][IVY_N+4];

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

      float[][] bands =

        {

          {+0.015f,20,0.2f,0.5f,7,1,2},

          {-0.100f,20,0.2f,0.0f,2,1,2}

        };

      for(int i=0; i<3*(IVY_N+1); i++)

        {

        cornerIndices[i+4] = -1;

        centerIndices[i+4] = -1;

        }

      cornerIndices[0] = 1;

      cornerIndices[1] = 0;

      cornerIndices[2] = 0;

      cornerIndices[3] = 0;

      centerIndices[0] = 0;

      centerIndices[1] = 0;

      centerIndices[2] = 0;

      centerIndices[3] = 0;

      vertices[0][0] = 0.0;

      vertices[0][1] = 0.0;

      vertices[0][2] = 0.0;

      vertices[1][0] =-2.0;

      vertices[1][1] = 0.0;

      vertices[1][2] = 0.0;

      vertices[2][0] = 0.0;

      vertices[2][1] =-2.0;

      vertices[2][2] = 0.0;

      vertices[3][0] = 0.0;

      vertices[3][1] = 0.0;

      vertices[3][2] =-2.0;

      vertIndices[0][0] = 2;

      vertIndices[0][1] = 0;

      vertIndices[0][2] = 1;

      vertIndices[3][0] = 2;

      vertIndices[3][1] = 0;

      vertIndices[3][2] = 1;

      vertIndices[1][0] = 3;

      vertIndices[1][1] = 0;

      vertIndices[1][2] = 2;

      vertIndices[4][0] = 3;

      vertIndices[4][1] = 0;

      vertIndices[4][2] = 2;

      vertIndices[2][0] = 1;

      vertIndices[2][1] = 0;

      vertIndices[2][2] = 3;

      vertIndices[5][0] = 1;

      vertIndices[5][1] = 0;

      vertIndices[5][2] = 3;

      int N1 = 4;

      int N2 = N1 + IVY_N + 1;

      int N3 = N2 + IVY_N + 1;

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

        {

        double cos1 = Math.cos((IVY_N-i)*angle);

        double sin1 = Math.sin((IVY_N-i)*angle);

        double cos2 = Math.cos((      i)*angle);

        double sin2 = Math.sin((      i)*angle);

        vertices[N1+i][0] = CORR*(2*cos1-1.0) - 1.0;

        vertices[N1+i][1] = CORR*(2*sin1-1.0) - 1.0;

        vertices[N1+i][2] = 0.0;

        vertices[N2+i][0] = 0.0;

        vertices[N2+i][1] = CORR*(2*sin2-1.0) - 1.0;

        vertices[N2+i][2] = CORR*(2*cos2-1.0) - 1.0;

        vertices[N3+i][0] = CORR*(2*cos2-1.0) - 1.0;

        vertices[N3+i][1] = 0.0;

        vertices[N3+i][2] = CORR*(2*sin2-1.0) - 1.0;

        vertIndices[0][i+3] = N1 + i;

        vertIndices[1][i+3] = N2 + i;

        vertIndices[2][i+3] = N3 + i;

        vertIndices[3][i+3] = N1 + i;

        vertIndices[4][i+3] = N2 + i;

        vertIndices[5][i+3] = N3 + i;

        }

      float C = 1.0f - SQ2/2;

      float[] convexCenter = new float[] {-C,-C,-C};

      return new ObjectShape(vertices,vertIndices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), convexCenter);

      }

    else

      {

      final float angle = (float)Math.PI/(2*IVY_N);

      final float CORR  = 1.0f - 2*IVY_D;

      double[][] vertices = new double[2*IVY_N][3];

      int[][] vert_indices = new int[2][2*IVY_N];

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

      int[] indexes    = new int[2*IVY_N];

      float[][] corners= new float[][] { {0.05f,0.20f} };

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

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

        {

        double sin = Math.sin(i*angle);

        double cos = Math.cos(i*angle);

        vertices[i      ][0] = CORR*(1.0f-2*cos);

        vertices[i      ][1] = CORR*(1.0f-2*sin);

        vertices[i      ][2] = 0;

        vertices[i+IVY_N][0] = CORR*(2*cos-1.0f);

        vertices[i+IVY_N][1] = CORR*(2*sin-1.0f);

        vertices[i+IVY_N][2] = 0;

        }

      for(int i=0; i<2*IVY_N; i++)

        {

        vert_indices[0][i] = i;

        vert_indices[1][i] = 2*IVY_N-1-i;

        }

      for(int i=0; i<2*IVY_N; i++)

        {

        indexes[i] = -1;

        }

      indexes[0] = indexes[IVY_N] = 0;

      float[][] bands =

        {

          {+0.03f,35,0.5f,0.5f,5,0,0},

          {+0.10f,45,0.5f,0.0f,2,0,0}

        };

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

      }

    }

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

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

    {

    if( mQuats==null ) initializeQuats();

    switch(cubit)

      {

      case  0: return mQuats[0];

      case  1: return mQuats[2];

      case  2: return mQuats[3];

      case  3: return mQuats[1];

      case  4: return mQuats[8];

      case  5: return mQuats[11];

      case  6: return mQuats[10];

      case  7: return mQuats[9];

      case  8: return mQuats[0];

      case  9: return mQuats[2];

      }

    return mQuats[0];

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 2;

    }

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

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

    {

    return cubit<4 ? 0:1;

    }

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

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

    {

    if( variant==0 ) return face<3 ? 0 : -1;

    else             return face<1 ? 1 : -1;

    }

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

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

    {

    if( mFaceMap==null )

      {

      mFaceMap = new int[][]

         {

           { 4, 0, 2, -1,-1,-1 },

           { 5, 1, 2, -1,-1,-1 },

           { 4, 1, 3, -1,-1,-1 },

           { 5, 0, 3, -1,-1,-1 },

           { 0, -1,-1,-1,-1,-1 },

           { 1, -1,-1,-1,-1,-1 },

           { 2, -1,-1,-1,-1,-1 },

           { 3, -1,-1,-1,-1,-1 },

           { 4, -1,-1,-1,-1,-1 },

           { 5, -1,-1,-1,-1,-1 },

         };

      }

    return mFaceMap[cubit][face];

    }

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

  public ObjectSticker retSticker(int sticker)

    {

    if( mStickers==null )

      {

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

      mStickers = new ObjectSticker[NUM_STICKERS];

      float D = (float)(Math.PI/4);

      final float[][] angles = { { 0,0,D },{ D,D } };

      final float[][] radii  = { { 0,0.04f,0 },{ 0.06f,0.06f } };

      final float[] strokes = { 0.03f, 0.08f };

      if( ObjectControl.isInIconMode() )

        {

        float mult = 1.5f;

        strokes[0]*=mult;

        strokes[1]*=mult;

        }

      for(int s=0; s<NUM_STICKERS; s++) mStickers[s] = new ObjectSticker(STICKERS[s], angles[s],radii[s],strokes[s]);

      }

    return mStickers[sticker];

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[] getBasicAngle()

    {

    if( mBasicAngle ==null ) mBasicAngle = new int[] { 3,3,3,3 };

    return mBasicAngle;

    }

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

  public ObjectType intGetObjectType(int[] numLayers)

    {

    return ObjectType.IVY_2;

    }

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

  public String getObjectName()

    {

    return "Ivy Cube";

    }

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

  public String getInventor()

    {

    return "Eitan Cher";

    }

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

  public int getYearOfInvention()

    {

    return 2009;

    }

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

  public int getComplexity()

    {

    return 1;

    }

}