TwistyPuzzleLib

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

// Copyright 2021 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.helpers.ObjectShape;

import org.distorted.objectlib.metadata.Metadata;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.metadata.ListObjects;

import org.distorted.objectlib.shape.ShapeTetrahedron;

import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;

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

public class TwistyPyraminxDuo 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 static final float F = 0.60f;  // let point A = corner of the tetrahedron; B - center of tetrahedron face;

                                         // C - corner of the triangular face cubit. Then C = A + F(B-A)

  private static final float G = 0.02f;  // this defines the gap between two corner cubits. 0.0 -> no gap.

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private int[] mQuatIndex;

  private float[][] mCuts;

  private float[][] mCenters;

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

  public TwistyPyraminxDuo(int iconMode, Static4D quat, Static3D move, float scale, Metadata meta, InitAssets asset)

    {

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

    }

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

  @Override

  public float[][] returnRotationFactor()

    {

    float[] f = new float[] {1.4f,1.8f};

    return new float[][] { f,f,f,f };

    }

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

// single edge; only the tip layers move

  public int[][] getScrambleEdges()

    {

    if( mEdges==null ) mEdges = new int[][] { {2,0,3,0,6,0,7,0,10,0,11,0,14,0,15,0} };

    return mEdges;

    }

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

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

    {

    if( mCuts==null )

      {

      float[] cut = { 0.0f };

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

      }

    return mCuts;

    }

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

  public boolean[][] getLayerRotatable(int[] numLayers)

    {

    boolean[] tmp = {true,true};

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

    }

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

  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;

    }

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

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

    {

    if( mCenters==null )

      {

      mCenters = new float[][]

         {

           { 0.000f, -SQ2/2, 1.000f },

           { 0.000f, -SQ2/2,-1.000f },

           {-1.000f,  SQ2/2, 0.000f },

           { 1.000f,  SQ2/2, 0.000f },

           { 0.000f,  SQ2/6, 1.0f/3 },

           { 0.000f,  SQ2/6,-1.0f/3 },

           {-1.0f/3, -SQ2/6, 0.000f },

           { 1.0f/3, -SQ2/6, 0.000f },

         };

      }

    return mCenters;

    }

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

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

    {

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

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      float v1x = G*(0.5f);

      float v1y = G*(SQ2/2);

      float v1z = G*(-0.5f);

      float v2x = G*(-0.5f);

      float v2y = G*(SQ2/2);

      float v2z = G*(-0.5f);

      float v3x = 0.0f;

      float v3y = 0.0f;

      float v3z = G*(-1.0f);

      return new float[][]

          {

              { 0.0f, 0.0f,0.0f},

              { 0.5f -v1x, SQ2/2 -v1y,-0.5f -v1z},

              {-0.5f -v2x, SQ2/2 -v2y,-0.5f -v2z},

              { 0.0f -v3x, 0.0f  -v3y,-1.0f -v3z},

              { 0.0f, (2*SQ2/3)*F, -2*F/3},

              {  F/3, (SQ2/3)*F, -F},

              { -F/3, (SQ2/3)*F, -F},

              { (1-F)*0.5f -v1x, (1-F)*(SQ2/2)+(2*SQ2/3)*F -v1y, -(1-F)*0.5f-F*(2.0f/3) -v1z},

              {-(1-F)*0.5f -v2x, (1-F)*(SQ2/2)+(2*SQ2/3)*F -v2y, -(1-F)*0.5f-F*(2.0f/3) -v2z},

              { F/3        -v3x, (SQ2/3)*F                 -v3x, -1.0f                  -v3z},

              { (1-F)*0.5f+F/3 -v1x, (1-F)*(SQ2/2)+F*(SQ2/3) -v1y, -(1-F)*0.5f-F -v1z},

              {-(1-F)*0.5f-F/3 -v2x, (1-F)*(SQ2/2)+F*(SQ2/3) -v2y, -(1-F)*0.5f-F -v2z},

              {-F/3            -v3x, (SQ2/3)*F               -v3y, -1.0f         -v3z},

              {0.0f, (1-G)*SQ2/2, (1-G)*(-1.0f) }

          };

      }

    else

      {

      return new float[][]

          {

              {  0.0f, (1-F)*(-2*SQ2/3), (1-F)*(2.0f/3) },

              { (1-F), (1-F)*(SQ2/3), (1-F)*(-1.0f/3) },

              { (F-1), (1-F)*(SQ2/3), (1-F)*(-1.0f/3) },

              {0,-SQ2/3,-1.0f/3}

          };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int[][] indices =

          {

              {0,1,7,4,8,2},

              {0,3,9,5,10,1},

              {0,2,11,6,12,3},

              {1,10,13,7},

              {3,12,13,9},

              {2,8,13,11},

              {4,7,13},

              {4,13,8},

              {5,9,13},

              {5,13,10},

              {6,11,13},

              {6,13,12}

          };

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

      }

    else

      {

      int[][] indices =

          {

              {0,1,2},

              {3,1,0},

              {3,2,1},

              {3,0,2}

          };

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

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

      float[][] bands = { {height,35,0.25f,0.5f,5,1,1},{0.001f,35,0.25f,0.5f,5,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

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

      float[][] bands = { {height,35,0.20f,0.6f,5,0,0}, {0.001f,35,0.20f,0.6f,3,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

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

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

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

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

      }

    else

      {

      float[][] corners = { {0.02f,0.10f} };

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

      float[][] centers = { {0,-SQ2/3,-1.0f/3} };

      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<4 ? 0:1;

    }

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

  public float getStickerRadius()

    {

    return 0.07f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.07f : 0.06f;

    }

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

  public float[][][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][] getBasicAngles()

    {

    if( mBasicAngle==null )

      {

      int[] tmp = {3,3};

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

      }

    return mBasicAngle;

    }

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

  public String getShortName()

    {

    return ListObjects.PDUO_2.name();

    }

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

  public String[][] getTutorials()

    {

    return new String[][]{

                          {"gb","xB9OFNyi-Uk","Pyraminx Duo: Beginner","Z3"},

                          {"gb","P-Zt7GEyYuE","Pyraminx Duo: Optimal","Z3"},

                          {"es","ojDwj9Ld3t8","Tutorial: Pyraminx Duo","RubikArt"},

                          {"ru","pTaHQOqp4L8","Как собрать Pyraminx Duo","GCubing"},

                          {"pl","r9pW0933vz4","Poradnik mini - Pyraminx Duo","Speedcubing Nation"},

                          {"vn","F2XahC2fYuk","Hướng dẫn giải Pyraminx Duo","Rubik For Everyone"},

                          {"tw","xNn5bnYOGjA","金字塔二重奏 \"最少步法\" 教學","不正常魔術方塊研究中心"},

                         };

    }

}