TwistyPuzzleLib

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

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 org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.signature.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.signature.ObjectConstants;

import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.shape.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 int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

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

  public TwistyPyraminx(int iconMode, Static4D quat, Static3D move, float scale, InitData data, InitAssets asset)

    {

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

    }

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

  @Override

  public float[][] returnRotationFactor()

    {

    int numL= getNumLayers()[0];

    float[][] factor = new float[4][numL];

    for(int ax=0; ax<4; ax++)

      for(int la=0; la<numL; la++) factor[ax][la] = ((float)numL)/(numL-la);

    return factor;

    }

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

// edge[i] is the state after moving layer i (0 is the largest)

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      int nL = getNumLayers()[0];

      mEdges = new int[nL][];

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

        {

        int numEnabledMoves = 2*(nL-i);

        mEdges[i] = new int[4*2*numEnabledMoves];

        int index = 0;

        int startMove= 0;

        int offset = (i==nL-1 ? 2:0);  // if the last move was a tip, the only possible

                                       // next move is the second-to-largest layer.

        fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves);

        index += (2*numEnabledMoves);

        startMove += (2*nL);

        fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves);

        index += (2*numEnabledMoves);

        startMove += (2*nL);

        fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves);

        index += (2*numEnabledMoves);

        startMove += (2*nL);

        fillEdge(mEdges[i],index,startMove,offset,numEnabledMoves);

        }

      }

    return mEdges;

    }

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

  private void fillEdge(int[] edge, int index, int move, int offset, int num)

    {

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

      {

      edge[index+2*i  ] = (move+offset);

      edge[index+2*i+1] = (i+offset)/2;

      move++;

      }

    }

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

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

      float cut = (SQ6/6)*(2-numL*0.5f);

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

        {

        mCuts[0][i] = cut;

        mCuts[1][i] = cut;

        mCuts[2][i] = cut;

        mCuts[3][i] = cut;

        cut += SQ6/3;

        }

      }

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

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      return new float[][] { { 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} };

      }

    else

      {

      return new float[][] { {-0.5f, SQ2/4, 0.0f},{ 0.5f, SQ2/4, 0.0f},{ 0.0f,-SQ2/4, 0.5f},{ 0.0f,-SQ2/4,-0.5f} };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      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(getVertices(variant), indices);

      }

    else

      {

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

      return new ObjectShape(getVertices(variant), indices);

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int numL = getNumLayers()[0];

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

    int angle = 25;

    float R = 0.7f;

    float S = 0.5f;

    if( variant==0 )

      {

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

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

      float[][] bands = { {height,angle,R,S,N,E,E} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

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

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

      float[][] bands = { {height,angle,R,S,N,E,E} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

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

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

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

      return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);

      }

    else

      {

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

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

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

      return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);

      }

    }

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

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

      case 6: return ObjectType.PYRA_6.name();

      }

    return ObjectType.PYRA_3.name();

    }

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

  public ObjectSignature getSignature()

    {

    switch(getNumLayers()[0])

      {

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

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

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

      case 6: return new ObjectSignature(ObjectConstants.PYRA_6);

      }

    return null;

    }

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

  public String getObjectName()

    {

    switch(getNumLayers()[0])

      {

      case 3: return "Pyraminx";

      case 4: return "Master Pyraminx";

      case 5: return "Professor's Pyraminx";

      case 6: return "Royal Pyraminx";

      }

    return null;

    }

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

  public String getInventor()

    {

    switch(getNumLayers()[0])

      {

      case 3: return "Uwe Meffert";

      case 4: return "Katsuhiko Okamoto";

      case 5:

      case 6: return "Timur Evbatyrov";

      }

    return null;

    }

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

  public int getYearOfInvention()

    {

    switch(getNumLayers()[0])

      {

      case 3: return 1970;

      case 4: return 2002;

      case 5:

      case 6: return 2011;

      }

    return 1970;

    }

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

  public int getComplexity()

    {

    switch(getNumLayers()[0])

      {

      case 3: return 1;

      case 4: return 2;

      case 5:

      case 6: 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","wZu3OAuNY5Q","金字塔方塊 教學","不正常魔術方塊研究中心"},

                         };

      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"},

                          {"tw","Tghr4ow9Ckk","四階金字塔 教學","不正常魔術方塊研究中心"},

                         };

      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"},

                          {"tw","X3NxqT8bt8s","五階金字塔 教學","不正常魔術方塊研究中心"},

                         };

      case 6: return new String[][] {

                          {"gb","1u6FPbkp0-c","Royal Pyraminx: a Tutorial","Superantoniovivaldi"},

                          {"es","7px2uG7zhVk","Royal Pyraminx Tutorial","Gadi Rubik"},

                          {"tw","hbK2L28hEvM","六階金字塔 教學","不正常魔術方塊研究中心"},

                         };

      }

    return null;

    }

}