TwistyPuzzleLib

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

// Copyright 2022 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 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.signature.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.signature.ObjectConstants;

import org.distorted.objectlib.metadata.ListObjects;

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

public class TwistyCrystal extends TwistyDodecahedron

{

  private static final float A = (SQ5+5)/10;

  private float[][] mCuts;

  private float[][] mPosition;

  private int[] mQuatIndex;

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

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

    {

    super(iconMode, quat, move, scale, meta, asset);

    }

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

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

    {

    if( mPosition==null )

      {

      if( mEdgeMap==null ) mEdgeMap = initializeEdgeMap();

      if( mCenterCoords==null ) initializeCenterCoords();

      mPosition = new float[NUM_EDGES+NUM_CORNERS][3];

      for(int edge=0; edge<NUM_EDGES; edge++)

        {

        float[] c1 = mCorners[ mEdgeMap[edge][0] ];

        float[] c2 = mCorners[ mEdgeMap[edge][1] ];

        mPosition[edge][0] = (c1[0]+c2[0])/2;

        mPosition[edge][1] = (c1[1]+c2[1])/2;

        mPosition[edge][2] = (c1[2]+c2[2])/2;

        }

      System.arraycopy(mCorners, 0, mPosition, NUM_EDGES, NUM_CORNERS);

      }

    return mPosition;

    }

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

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

    {

    if( mQuatIndex==null ) mQuatIndex = new int[] {  0,17,12,13,20, 4,25, 5,24,16,

                                                     9,21, 1,34, 8,11,30,43,26,14,

                                                    15,45,33,28,10, 2,29, 6, 7, 3,

                                                     0, 2,20,42,13,41,16,33, 8,51,

                                                     1,25,12,27, 4, 3,21,28, 5, 6 };

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    float[] blueCenter = mCenterCoords[0];

    float[] greeCenter = mCenterCoords[1];

    float[] pinkCenter = mCenterCoords[2];

    if( variant==0 )

      {

      float B = greeCenter[2]-mCorners[0][2];

      float C = A*mCorners[0][1]+(1.0f-A)*mCorners[2][1];

      float D = greeCenter[0];

      return new float[][]

         {

             { 0.0f, C, 0,0f },

             { 0.0f,-C, 0,0f },

             {   -D,0.0f,  B },

             {   +D,0.0f,  B },

         };

      }

    else

      {

      float X = mCorners[0][0];

      float Y = mCorners[0][1];

      float Z = mCorners[0][2];

      float X1 = A*mCorners[0][0]+(1.0f-A)*mCorners[16][0];

      float Y1 = A*mCorners[0][1]+(1.0f-A)*mCorners[16][1];

      float Z1 = A*mCorners[0][2]+(1.0f-A)*mCorners[16][2];

      float X2 = A*mCorners[0][0]+(1.0f-A)*mCorners[12][0];

      float Y2 = A*mCorners[0][1]+(1.0f-A)*mCorners[12][1];

      float Z2 = A*mCorners[0][2]+(1.0f-A)*mCorners[12][2];

      float X3 = A*mCorners[0][0]+(1.0f-A)*mCorners[ 2][0];

      float Y3 = A*mCorners[0][1]+(1.0f-A)*mCorners[ 2][1];

      float Z3 = A*mCorners[0][2]+(1.0f-A)*mCorners[ 2][2];

      return new float[][]

         {

             {0.0f, 0.0f, 0.0f},

             {X1-X, Y1-Y, Z1-Z},

             {X2-X, Y2-Y, Z2-Z},

             {X3-X, Y3-Y, Z3-Z},

             { greeCenter[0]-X, greeCenter[1]-Y, greeCenter[2]-Z },

             { pinkCenter[0]-X, pinkCenter[1]-Y, pinkCenter[2]-Z },

             { blueCenter[0]-X, blueCenter[1]-Y, blueCenter[2]-Z }

         };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int[][] indices =

         {

             {1,0,2},

             {0,1,3},

             {2,3,1},

             {3,2,0}

         };

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

      }

    else

      {

      int[][] indices =

         {

             { 5,3,0,1 },

             { 4,2,0,3 },

             { 6,1,0,2 },

             { 5,4,3 },

             { 4,6,2 },

             { 6,5,1 },

             { 6,4,5 }

         };

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int angle = 15;

    float R = 0.7f;

    float S = 0.5f;

    if( variant==0 )

      {

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

      float h2 = isInIconMode() ? 0.001f : 0.01f;

      float[][] bands = { {h1,angle,R,S,5,1,0}, {h2,angle,R,S,5,1,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

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

      float h2 = isInIconMode() ? 0.001f : 0.01f;

      float[][] bands = { {h1,angle,R,S,5,1,0}, {h2,angle,R,S,5,1,0}, {h2,angle,R,S,3,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

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

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

      float[][] centers= { { 0.0f,0.0f,-mCorners[0][2] } };

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

      }

    else

      {

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

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

      float[][] centers= { { 0.0f,-1.5f,-mCorners[0][2] } };

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

    }

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

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

    {

    if( mCuts==null )

      {

      float CUT = 1.5f; // TODO

      float[] cut = new float[] { -CUT,+CUT };

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

      }

    return mCuts;

    }

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

  public float getStickerRadius()

    {

    return 0.18f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.22f : 0.15f;

    }

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

  public float[][][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public String getShortName()

    {

    return ListObjects.CRYS_3.name();

    }

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

  public ObjectSignature getSignature()

    {

    return new ObjectSignature(ObjectConstants.CRYS_3);

    }

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

  public String getObjectName()

    {

    return "Pyraminx Crystal";

    }

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

  public String getInventor()

    {

    return "Aleh Hladzilin";

    }

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

  public int getYearOfInvention()

    {

    return 2006;

    }

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

  public float getComplexity()

    {

    return 3.0f;

    }

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

  public String[][] getTutorials()

    {

    return new String[][]{

                          {"gb","tFSGC9esay0","Pyraminx Crystal Tutorial","twistypuzzling"},

                          {"es","AmrIwSICFB8","Como resolver Pyraminx Crystal","Tutoriales Rubik"},

                          {"ru","3AKeT8JIU0E","Как собрать Crystal Pyraminx","RBcuber"},

                          {"fr","SPsrHhQzmVg","Résolution du Pyraminx Crystal","asthalis"},

                          {"de","EH4sw7_21eA","Crystal Pyraminx Tutorial","GerCubing"},

                          {"pl","AmrIwSICFB8","Crystal Pyraminx TUTORIAL PL","MrUK"},

                          {"br","13pz0cNBVow","Como resolver o Pyraminx Crystal 1/3","RafaelCinoto"},

                          {"br","eT654oZsBg0","Como resolver o Pyraminx Crystal 2/3","RafaelCinoto"},

                          {"br","MnooQbVFbfU","Como resolver o Pyraminx Crystal 3/3","RafaelCinoto"},

                          {"kr","o-w_ZzDrfFU","피라밍크스 크리스탈 해법 1/2","SlowCuberToumai"},

                          {"kr","ExMg8SAge4Q","피라밍크스 크리스탈 해법 2/2","SlowCuberToumai"},

                          {"vn","MxF4bKlnIMU","Tutorial N.28 - Pyraminx Crystal","Duy Thích Rubik"},

                         };

    }

}