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 float[][] mCuts;

  private int[][] mFaceMap;

  private int[] mQuatIndex;

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

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

    {

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

    }

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

// Back sides of the cubits here have all vertices on the walls and get mis-detected as external

// walls by the automatic sticker engine. Manually provide the (cubit face)<->(puzzle face) map.

  @Override

  public int getCubitFaceMap(int cubit, int face)

    {

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

    }

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

// ditto, manually provide the sticker coordinates.

  @Override

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

    }

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

  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 TouchControlHexahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

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

    {

    final float DIST_CORNER = numLayers[0]-1;

    final float DIST_CENTER = numLayers[0]-1;

    return new float[][]

      {

        { DIST_CORNER, DIST_CORNER, DIST_CORNER },

        {-DIST_CORNER, DIST_CORNER,-DIST_CORNER },

        {-DIST_CORNER,-DIST_CORNER, DIST_CORNER },

        { DIST_CORNER,-DIST_CORNER,-DIST_CORNER },

        { DIST_CENTER,           0,           0 },

        {-DIST_CENTER,           0,           0 },

        {           0, DIST_CENTER,           0 },

        {           0,-DIST_CENTER,           0 },

        {           0,           0, DIST_CENTER },

        {           0,           0,-DIST_CENTER },

      };

    }

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

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

    {

    if( mQuatIndex==null ) mQuatIndex = new int[] { 0,11,10,9, 5,8,7,6,0,11 };

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  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] = 1;

      indices[3][1] = 0;

      indices[3][2] = 2;

      indices[1][0] = 3;

      indices[1][1] = 0;

      indices[1][2] = 2;

      indices[4][0] = 2;

      indices[4][1] = 0;

      indices[4][2] = 3;

      indices[2][0] = 1;

      indices[2][1] = 0;

      indices[2][2] = 3;

      indices[5][0] = 3;

      indices[5][1] = 0;

      indices[5][2] = 1;

      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 + IVY_N-i;

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

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

        }

      return new ObjectShape(vertices, indices);

      }

    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] = 2*IVY_N-1-i;

        }

      return new ObjectShape(vertices, indices);

      }

    }

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

  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,5,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 int getNumCubitVariants(int[] numLayers)

    {

    return 2;

    }

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

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

    {

    return cubit<4 ? 0:1;

    }

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

  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[] getBasicAngles()

    {

    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;

    }

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

  public String[][] getTutorials()

    {

    return new String[][]{

                          {"gb","QMzeJobSu1M","How to Solve the Ivy Cube","Z3"},

                          {"es","2-Gf2cmEJDs","Resolver Ivy Cube","Cuby"},

                          {"ru","pbkfOCnnfsA","Как собрать Иви куб","Алексей Ярыгин"},

                          {"fr","mn7YTnYu3Uc","Comment résoudre le Ivy Cube","ValentinoCube"},

                          {"de","vaW5fSUG_O8","Ivy Cube","ThomasStadler"},

                          {"pl","8s_0VxNvFA8","Jak ułożyć Ivy Cube","DubiCube"},

                          {"kr","TmSPgjtSFac","15분만에 아이비큐브 완전정복하기!","초등취미생활"},

                         };

    }

}