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.touchcontrol.TouchControl.TC_TETRAHEDRON;

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

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

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.scrambling.ScrambleState;

import org.distorted.objectlib.main.ShapeTetrahedron;

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

public class TwistyPyraminx extends ShapeTetrahedron

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(     0,-SQ3/3,-SQ6/3),

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

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

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

         };

  private ScrambleState[] mStates;

  private int[][] mBasicAngle;

  private float[][] mCuts;

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

  public TwistyPyraminx(InitData data, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(data, meshState, iconMode, data.getNumLayers()[0], quat, move, scale, stream);

    }

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

  public ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int[] numLayers = getNumLayers();

      initializeScrambleStates(numLayers[0]);

      }

    return mStates;

    }

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

  private int[][] generateState(int start, int end)

    {

    int len = end-start+1;

    int[] tmp = new int[6*len];

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

      {

      tmp[6*i  ] = start;

      tmp[6*i+1] = -1;

      tmp[6*i+2] = start;

      tmp[6*i+3] = start;

      tmp[6*i+4] = +1;

      tmp[6*i+5] = start;

      start++;

      }

    return new int[][] {tmp,tmp,tmp,tmp};

    }

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

  private void initializeScrambleStates(int numLayers)

    {

    mStates = new ScrambleState[numLayers];

    for(int i=0; i<numLayers-1; i++)

      {

      mStates[i] = new ScrambleState( generateState(0,numLayers-1-i) );

      }

    mStates[numLayers-1] = new ScrambleState( generateState(1,numLayers-2) );

    }

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

  private void addTetrahedralLattice(int size, int index, float[][] pos)

    {

    final float DX = 1.0f;

    final float DY = SQ2/2;

    final float DZ = 1.0f;

    float startX = 0.0f;

    float startY =-DY*(size-1)/2;

    float startZ = DZ*(size-1)/2;

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

      {

      float currX = startX;

      float currY = startY;

      for(int x=0; x<layer+1; x++)

        {

        float currZ = startZ;

        for(int z=0; z<size-layer; z++)

          {

          pos[index] = new float[] {currX,currY,currZ};

          index++;

          currZ -= DZ;

          }

        currX += DX;

        }

      startX-=DX/2;

      startY+=DY;

      startZ-=DZ/2;

      }

    }

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

  private int getNumOctahedrons(int numLayers)

    {

    return (numLayers-1)*numLayers*(numLayers+1)/6;

    }

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

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

    {

    if( mCuts==null )

      {

      int numL = numLayers[0];

      mCuts = new float[4][numL-1];

      for(int i=0; i<numL-1; i++)

        {

        float cut = (1.0f+i-numL/4.0f)*(SQ6/3);

        mCuts[0][i] = cut;

        mCuts[1][i] = cut;

        mCuts[2][i] = cut;

        mCuts[3][i] = 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_TETRAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][] { {{1,2,3}},{{0,2,3}},{{0,1,3}},{{0,1,2}} };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlTetrahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlTetrahedron.FACE_AXIS;

    }

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

// there are (n^3-n)/6 octahedrons and ((n+1)^3 - (n+1))/6 tetrahedrons

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

    {

    int numL = numLayers[0];

    int numOcta = (numL-1)*numL*(numL+1)/6;

    int numTetra= numL*(numL+1)*(numL+2)/6;

    float[][] ret = new float[numOcta+numTetra][];

    addTetrahedralLattice(numL-1,      0,ret);

    addTetrahedralLattice(numL  ,numOcta,ret);

    return ret;

    }

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

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

    {

    return mObjectQuats[0];

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      float[][] vertices= { { 0.5f,0.0f,0.5f},{ 0.5f,0.0f,-0.5f},{-0.5f,0.0f,-0.5f},{-0.5f,0.0f,0.5f},{ 0.0f,SQ2/2,0.0f},{ 0.0f,-SQ2/2,0.0f} };

      int[][] indices   = { {3,0,4},{0,1,4},{1,2,4},{2,3,4},{5,0,3},{5,1,0},{5,2,1},{5,3,2} };

      return new ObjectShape(vertices, indices);

      }

    else

      {

      float[][] vertices= { {-0.5f, SQ2/4, 0.0f},{ 0.5f, SQ2/4, 0.0f},{ 0.0f,-SQ2/4, 0.5f},{ 0.0f,-SQ2/4,-0.5f} };

      int[][] indices   = { {2,1,0},{3,0,1},{3,2,0},{2,3,1} };

      return new ObjectShape(vertices, indices);

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int numL = getNumLayers()[0];

    float height = isInIconMode() ? 0.001f : 0.05f;

    if( variant==0 )

      {

      int N = numL==3? 6 : 5;

      int E = numL==3? 2 : 1;

      float[][] bands     = { {height,20,0.5f,0.8f,N,E,E} };

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

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

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

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

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

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

      }

    else

      {

      int N = numL==3? 6 : 5;

      int E = numL==3? 2 : 1;

      float[][] bands     = { {height,35,0.5f,0.8f,N,E,E} };

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

      float[][] corners   = { {0.06f,0.15f} };

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

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

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

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

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 2;

    }

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

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

    {

    return cubit<getNumOctahedrons(numLayers[0]) ? 0:1;

    }

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

  public float getStickerRadius()

    {

    return 0.08f;

    }

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

  public float getStickerStroke()

    {

    float stroke = 0.08f;

    if( isInIconMode() )

      {

      int[] numLayers = getNumLayers();

      switch(numLayers[0])

        {

        case 2: stroke*=1.0f; break;

        case 3: stroke*=1.4f; break;

        case 4: stroke*=1.7f; break;

        default:stroke*=1.9f; break;

        }

      }

    return stroke;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

// public API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][] getBasicAngles()

    {

    if( mBasicAngle ==null )

      {

      int num = getNumLayers()[0];

      int[] tmp = new int[num];

      for(int i=0; i<num; i++) tmp[i] = 3;

      mBasicAngle = new int[][] { tmp,tmp,tmp,tmp };

      }

    return mBasicAngle;

    }

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

  public String getShortName()

    {

    switch(getNumLayers()[0])

      {

      case 3: return ObjectType.PYRA_3.name();

      case 4: return ObjectType.PYRA_4.name();

      case 5: return ObjectType.PYRA_5.name();

      }

    return ObjectType.PYRA_3.name();

    }

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

  public ObjectSignature getSignature()

    {

    switch(getNumLayers()[0])

      {

      case 3: return new ObjectSignature(ObjectType.PYRA_3);

      case 4: return new ObjectSignature(ObjectType.PYRA_4);

      case 5: return new ObjectSignature(ObjectType.PYRA_5);

      }

    return null;

    }

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

  public String getObjectName()

    {

    switch(getNumLayers()[0])

      {

      case 3: return "Pyraminx";

      case 4: return "Master Pyraminx";

      case 5: return "Professor's Pyraminx";

      }

    return null;

    }

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

  public String getInventor()

    {

    switch(getNumLayers()[0])

      {

      case 3: return "Uwe Meffert";

      case 4: return "Katsuhiko Okamoto";

      case 5: return "Timur Evbatyrov";

      }

    return null;

    }

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

  public int getYearOfInvention()

    {

    switch(getNumLayers()[0])

      {

      case 3: return 1970;

      case 4: return 2002;

      case 5: return 2011;

      }

    return 1970;

    }

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

  public int getComplexity()

    {

    switch(getNumLayers()[0])

      {

      case 3: return 1;

      case 4: return 2;

      case 5: return 3;

      }

    return 4;

    }

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

  public String[][] getTutorials()

    {

    int[] numLayers = getNumLayers();

    switch(numLayers[0])

      {

      case 3: return new String[][] {

                          {"gb","xIQtn2qazvg","Pyraminx Layer By Layer","Z3"},

                          {"es","4cJJe9RAzAU","Resolver Pyraminx","Cuby"},

                          {"ru","F4_bhfWyVRQ","Как собрать ПИРАМИДКУ","Е Бондаренко"},

                          {"fr","Z2h1YI6jPes","Comment résoudre le Pyraminx","ValentinoCube"},

                          {"de","x_DMA8htJpY","Pyraminx lösen","Pezcraft"},

                          {"pl","uNpKpJfAa5I","Jak ułożyć: Pyraminx","DżoDżo"},

                          {"br","dtC0GNGyXqw","Como resolver o Pyraminx","Pedro Filho"},

                          {"kr","mO3excjvvoA","피라밍크스 맞추는 방법","iamzoone"},

                          {"vn","p9LUWUW5iYg","Tutorial N.4 - Pyraminx","Duy Thích Rubik"},

                    //    {"tw","YS3cDcP6Aro","金字塔方塊解法","1hrBLD"},

                         };

      case 4: return new String[][] {

                          {"gb","tGQDqDcSa6U","How to Solve the Master Pyraminx","Z3"},

                          {"es","74PIPm9-uPg","Resolver Master Pyraminx 4x4","Cuby"},

                          {"ru","-F_xJAwkobU","Как собрать Мастер Пираминкс"," Алексей Ярыгин"},

                          {"fr","F3gzBs7uvmw","Tuto: résoudre le Master Pyraminx","Spaghetti Cubing"},

                          {"de","3Q_bO7_FfAI","Master Pyraminx lösen","CubaroCubing"},

                          {"pl","EamwvhmHC7Q","4x4 (Master) Pyraminx PL","MrUk"},

                          {"br","cKql6YZ7yAg","Como resolver o Pyraminx 4x4 1/3","Rafael Cinoto"},

                          {"br","gtNQDPsN2Dg","Como resolver o Pyraminx 4x4 2/3","Rafael Cinoto"},

                          {"br","j8_-s4rd8mw","Como resolver o Pyraminx 4x4 3/3","Rafael Cinoto"},

                          {"kr","JlmBKaHESyY","마스터 피라밍크스 해법","주누후누"},

                          {"vn","AMCll82WcJY","Tutorial N.13 - Master Pyraminx","Duy Thích Rubik"},

                         };

      case 5: return new String[][] {

                          {"gb","2nsPEECDdN0","Professor Pyraminx Solve","RedKB"},

                          {"es","cSDj8OQK3TU","Tutorial del Professor Pyraminx","QBAndo"},

                          {"ru","gMp1tbDyDWg","Как собрать Professor Pyraminx","RBcuber"},

                          {"de","pCHx9bVMSgI","Professor Pyraminx Teil 1","Arvid Bollmann"},

                          {"de","iiNXJMVNmCM","Professor Pyraminx Teil 2","Arvid Bollmann"},

                          {"br","t2QJSSjNxPw","Resolver o Professor Pyraminx 1/4","Rafael Cinoto"},

                          {"br","mI6W6IFyVv0","Resolver o Professor Pyraminx 2/4","Rafael Cinoto"},

                          {"br","0HoOp6JlLSs","Resolver o Professor Pyraminx 3/4","Rafael Cinoto"},

                          {"br","Xg1jnCRsw_I","Resolver o Professor Pyraminx 4/4","Rafael Cinoto"},

                          {"vn","OHwPqp3kQdE","Professor Pyraminx làm chậm","TRẦN QUANG HÙNG"},

                         };

      }

    return null;

    }

}