TwistyPuzzleLib

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

// Copyright 2020 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_OCTAHEDRON;

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

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

import org.distorted.objectlib.touchcontrol.TouchControlOctahedron;

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

public class TwistyPyraminxDiamond extends ShapeOctahedron

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

         new Static3D(SQ2/2, 0, SQ2/2),

         new Static3D(    0, 1,     0),

         new Static3D(SQ2/2, 0,-SQ2/2)

         };

  private static final float D = 0.3f;  // Size of the small cubit in relation to the face of the octahedron.

                                        // Keep below 1/3.

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPositions;

  private int[] mQuatIndex;

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

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

    {

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

    }

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

  @Override

  protected float[][][] getStickerRadii()

    {

    float R1 = 0.13f;

    float R2 = 0.00f;

    float R3 = 0.13f;

    return new float[][][] { {{ R3,R3,R3,R2,R3,R3 }} , {{ R1,R1,R1 }} };

    }

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

  @Override

  public float[][] returnRotationFactor()

    {

    float C = 1.5f;

    float[] f = new float[] {C,C,C};

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

    }

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

// single edge; middle layers don't move

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      mEdges = new int[][]

        {

          {0,0,1,0,2,0,6,0,7,0,8,0,  9,0,10,0,11,0,15,0,16,0,17,0,  18,0,19,0,20,0,24,0,25,0,26,0}

        };

      }

    return mEdges;

    }

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

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

    {

    if( mCuts==null )

      {

      float C = 0.5f*SQ2;

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

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

      }

    return mCuts;

    }

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

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

    {

    boolean[] tmp = {true,false,true};

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

    }

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

  public int getTouchControlType()

    {

    return TC_OCTAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_SPLIT_EDGE;

    }

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

  public int[][][] getEnabled()

    {

    int[][] e0 = {{1},{2},{0}};

    int[][] e1 = {{1},{0},{2}};

    return new int[][][] { e0,e0,e0,e0,e1,e1,e1,e1 };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlOctahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlOctahedron.FACE_AXIS;

    }

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

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

    {

    if( mPositions==null )

      {

      float B0 = 1.5f*SQ2;

      float C0 = 1.5f;

      float A = 1.03f;  // move the centers 3% out - otherwise they look hidden.

      float B1 = 0.5f*SQ2*A;

      float C1 = A;

      mPositions = new float[][]

         {

             {  0, B0,  0 },

             {  0,-B0,  0 },

             { C0,  0, C0 },

             { C0,  0,-C0 },

             {-C0,  0, C0 },

             {-C0,  0,-C0 },

             {  0, B1, C1 },

             {  0, B1,-C1 },

             {  0,-B1, C1 },

             {  0,-B1,-C1 },

             { C1, B1,  0 },

             { C1,-B1,  0 },

             {-C1, B1,  0 },

             {-C1,-B1,  0 },

         };

      }

    return mPositions;

    }

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

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

    {

    if( mQuatIndex==null )

      {

      mQuatIndex = new int[] { 0,2,9,1,3,7, 0,5,3,11,1,2,4,8 };

      }

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      final float A0 = 1-D;

      final float H0 = -SQ2*(1-D);

      final float A1 = 0.75f;

      final float H1 = -0.75f*SQ2;

      final float H2 = -SQ2 + 0.25f*SQ2*D;

      final float A2 = 0.0f + 0.75f*D;

      final float B2 = 1.0f - 0.25f*D;

      final float A3 = 0.25f + 0.5f*D;

      final float H3 = (-1.25f + 0.5f*D)*SQ2;

      return new float[][]

        {

            {  0,  0,  0 }, //0

            {  0, H0, A0 },

            { A0, H0,  0 },

            {  0, H0,-A0 },

            {-A0, H0,  0 }, //4

            {  0, H0,  0 },

            { A1, H1, A1 },

            { A1, H1,-A1 },

            {-A1, H1,-A1 },

            {-A1, H1, A1 }, //9

            { A2, H2, B2 },

            { B2, H2,-A2 },

            {-A2, H2,-B2 },

            {-B2, H2, A2 },

            { B2, H2, A2 }, //14

            { A2, H2,-B2 },

            {-B2, H2,-A2 },

            {-A2, H2, B2 },

            { A3, H3, A3 },

            { A3, H3,-A3 }, //19

            {-A3, H3,-A3 },

            {-A3, H3, A3 }

        };

      }

    else

      {

      return new float[][]

        {

            {-1.5f*D, -0.5f*SQ2*D, 0.5f*D},

            { 1.5f*D, -0.5f*SQ2*D, 0.5f*D},

            { 0.0f  ,       SQ2*D,     -D},

            { 0.0f  , -0.5f*SQ2  ,-1.0f  }

        };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int[][] indices =

          {

              {0,9,17,1,10,6},

              {0,6,14,2,11,7},

              {0,7,15,3,12,8},

              {0,8,16,4,13,9},

              {6,10,18,14},

              {7,11,19,15},

              {8,12,20,16},

              {9,13,21,17},

              {5,18,10,1},

              {5,1,17,21},

              {5,21,13,4},

              {5,4,16,20},

              {5,20,12,3},

              {5,3,15,19},

              {5,19,11,2},

              {5,2,14,18}

          };

      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)

    {

    int angle = 20;

    float R = 0.7f;

    float S = 0.5f;

    if( variant==0 )

      {

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

      float[][] bands = { {height,angle,R,S,5,1,0},{0.001f,angle,R,S,5,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

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

      float[][] bands = { {height,angle,R,S,5,1,0},{0.001f,angle,R,S,5,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.03f,0.20f},{0.03f,0.15f} };

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

      float[][] centers = { {0.0f,-1.5f*SQ2,0.0f} };

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

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

      }

    else

      {

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

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

      float[][] centers = { {0,-SQ2/2,-1.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<6 ? 0:1;

    }

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

// overriding getStickerRadii()

  public float getStickerRadius()

    {

    return 0.0f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.20f : 0.11f;

    }

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

  public float[][][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][] getBasicAngles()

    {

    if( mBasicAngle ==null )

      {

      int[] tmp = {4,4,4};

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

      }

    return mBasicAngle;

    }

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

  public String getShortName()

    {

    return ListObjects.PDIA_3.name();

    }

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

  public String[][] getTutorials()

    {

    return new String[][] {

                           {"gb","s5TdrKGH-DE","Solve the Pyraminx Diamond","TDRP Cubing"},

                           {"es","006L2qc1XoA","el Pyraminx Diamond","Spartan626"},

                           {"pl","AVRRHVgIeh4","Pyraminx Diamond TUTORIAL PL","MrUK"},

                           {"br","6SWwZUAK4U0","Pyraminx Diamond Solve","Cubo vicio"},

                           {"tw","76M-RMl70w0","Pyraminx Diamond","不正常魔術方塊研究中心"},

                          };

    }

}