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.helpers.ObjectFaceShape;

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.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)

         };

  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;

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

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

    {

    super(numL, meshState, 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 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 getTouchControlType()

    {

    return TC_HEXAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    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-2*IVY_D;

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

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

      vertices[0][0] = 0;

      vertices[0][1] = 0;

      vertices[0][2] = 0;

      vertices[1][0] =-2;

      vertices[1][1] = 0;

      vertices[1][2] = 0;

      vertices[2][0] = 0;

      vertices[2][1] =-2;

      vertices[2][2] = 0;

      vertices[3][0] = 0;

      vertices[3][1] = 0;

      vertices[3][2] =-2;

      indices[0][0] = 2;

      indices[0][1] = 0;

      indices[0][2] = 1;

      indices[3][0] = 2;

      indices[3][1] = 0;

      indices[3][2] = 1;

      indices[1][0] = 3;

      indices[1][1] = 0;

      indices[1][2] = 2;

      indices[4][0] = 3;

      indices[4][1] = 0;

      indices[4][2] = 2;

      indices[2][0] = 1;

      indices[2][1] = 0;

      indices[2][2] = 3;

      indices[5][0] = 1;

      indices[5][1] = 0;

      indices[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++)

        {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        }

      return new ObjectShape(vertices, indices, 3);

      }

    else

      {

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

      final float CORR  = 1-2*IVY_D;

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

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

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

        {

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

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

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

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

        vertices[i      ][2] = 0;

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

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

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

        }

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

        {

        indices[0][i] = i;

        indices[1][i] = i;

        }

      return new ObjectShape(vertices, indices, 1);

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

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

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

      int[] bandIndices  = { 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} };

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

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

      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;

      float C = 1-SQ2/2;

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

      return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,convexCenter);

      }

    else

      {

      int[] bandIndices= { 0,1 };

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

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

      float[][] bands  = { {+0.03f,35,0.5f,0.5f,5,0,0}, {-0.10f,45,0.5f,0.0f,2,0,0} };

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

      for(int i=0; i<2*IVY_N; i++) indexes[i] = -1;

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

      return new ObjectFaceShape(bands,bandIndices,corners,indexes,centers,indexes, 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 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 void adjustStickerCoords()

    {

    mStickerCoords = new float[][]

          {

            { 0.29258922f, -0.5f, 0.29258922f, 0.29258922f, -0.5f, 0.29258922f },

            { -0.5f, 0.5f, 0.5f, -0.5f }

          };

    }

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

  public float getStickerRadius()

    {

    return 0.19f;

    }

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

  public float getStickerStroke()

    {

    return ObjectControl.isInIconMode() ? 0.16f : 0.12f;

    }

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

  public float[][] getStickerAngles()

    {

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

    return new float[][] { { 0,0,D },{ D,D } };

    }

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

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

    }

}