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

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

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

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectSignatures;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.shape.ShapeHexahedron;

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

public class TwistyRex extends ShapeHexahedron

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D( SQ3/3, SQ3/3, SQ3/3),

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

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

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

         };

  public static final float REX_D = 0.2f;

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPosition;

  private int[] mQuatIndex;

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

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

    {

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

    }

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

  @Override

  public float[][] returnRotationFactor()

    {

    float C = 1.5f;

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

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

    }

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

  @Override

  public void adjustStickerCoords()

    {

    mStickerCoords = new float[][]

          {

             { 0.35f, -0.35f, -0.1428f, 0.5f, -0.5f, 0.1428f },

             { -0.5f, 0.0f, 0.0f, -0.5f, 0.5f, 0.0f, 0.0f, 0.5f },

             { 0.00f, -0.200f, 0.525f, 0.105f, -0.525f, 0.105f }

          };

    }

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

// single state; middle layer doesn't move.

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      mEdges = new int[][] { { 0,0,1,0, 4,0,5,0, 6,0,7,0, 10,0,11,0, 12,0,13,0, 16,0,17,0, 18,0,19,0, 22,0,23,0 } };

      }

    return mEdges;

    }

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

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

    {

    if( mCuts==null )

      {

      float C = SQ3*0.45f; // bit less than 1/2 of the length of the main diagonal

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

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

      }

    return mCuts;

    }

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

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

    {

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

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

    }

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

  public int getTouchControlType()

    {

    return TC_HEXAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_SPLIT_CORNER;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

          {{0,1},{3,1},{2,3},{0,2}},

          {{2,3},{3,1},{0,1},{0,2}},

          {{1,2},{0,1},{0,3},{2,3}},

          {{1,2},{2,3},{0,3},{0,1}},

          {{0,3},{0,2},{1,2},{1,3}},

          {{1,2},{0,2},{0,3},{1,3}},

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlHexahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

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

    {

    if( mPosition==null )

      {

      final float DIST1= 1.50f;

      final float DIST2= (1+2*REX_D)/2;

      final float DIST3= 1.53f;

      mPosition = new float[][]

        {

          { +DIST2, -DIST2, +DIST3 },

          { -DIST2, +DIST2, +DIST3 },

          { +DIST2, +DIST2, -DIST3 },

          { -DIST2, -DIST2, -DIST3 },

          { +DIST2, +DIST3, -DIST2 },

          { -DIST2, +DIST3, +DIST2 },

          { +DIST2, -DIST3, +DIST2 },

          { -DIST2, -DIST3, -DIST2 },

          { +DIST3, +DIST2, -DIST2 },

          { +DIST3, -DIST2, +DIST2 },

          { -DIST3, +DIST2, +DIST2 },

          { -DIST3, -DIST2, -DIST2 },

          { +DIST2, +DIST2, +DIST3 },

          { -DIST2, -DIST2, +DIST3 },

          { +DIST2, -DIST2, -DIST3 },

          { -DIST2, +DIST2, -DIST3 },

          { -DIST2, +DIST3, -DIST2 },

          { +DIST2, +DIST3, +DIST2 },

          { -DIST2, -DIST3, +DIST2 },

          { +DIST2, -DIST3, -DIST2 },

          { +DIST3, +DIST2, +DIST2 },

          { +DIST3, -DIST2, -DIST2 },

          { -DIST3, +DIST2, -DIST2 },

          { -DIST3, -DIST2, +DIST2 },

          { +0.00f, +0.00f, +DIST3 },

          { +0.00f, +0.00f, -DIST3 },

          { +0.00f, +DIST3, +0.00f },

          { +0.00f, -DIST3, +0.00f },

          { +DIST3, +0.00f, +0.00f },

          { -DIST3, +0.00f, +0.00f },

          { +0.00f, +DIST1, +DIST1 },

          { +DIST1, +0.00f, +DIST1 },

          { +0.00f, -DIST1, +DIST1 },

          { -DIST1, +0.00f, +DIST1 },

          { +DIST1, +DIST1, +0.00f },

          { +DIST1, -DIST1, +0.00f },

          { -DIST1, -DIST1, +0.00f },

          { -DIST1, +DIST1, +0.00f },

          { +0.00f, +DIST1, -DIST1 },

          { +DIST1, +0.00f, -DIST1 },

          { +0.00f, -DIST1, -DIST1 },

          { -DIST1, +0.00f, -DIST1 },

        };

      }

    return mPosition;

    }

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

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

    {

    if( mQuatIndex==null )

      {

      mQuatIndex = new int[] {

                              0,10, 9,11, 7, 1, 6, 4, 2, 5, 3, 8,

                              0,10, 9,11, 7, 1, 6, 4, 2, 5, 3, 8,

                              0, 9, 1, 4, 2, 3,

                              0, 2,10, 8, 1, 4, 6, 7,11, 5, 9, 3

                             };

      }

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      return new float[][] { {-0.10f,+0.70f,0},{-0.70f,+0.10f,0},{+0.65f,-0.71f,0},{+0.71f,-0.65f,0},{0,0.05f,-0.2f} };

      }

    else if( variant==1 )

      {

      return new float[][] { {-0.10f,-0.70f,0},{-0.70f,-0.10f,0},{+0.65f,+0.71f,0},{+0.71f,+0.65f,0},{0,-0.05f,-0.2f} };

      }

    else if( variant==2 )

      {

      float G = 3*REX_D;

      return new float[][] { { -G, 0, 0 },{ 0,-G, 0 },{ +G, 0, 0 },{ 0,+G,0 },{ 0, 0,-G} };

      }

    else

      {

      float E = 1.5f - 3*REX_D;

      float F = 1.5f;

      return new float[][] { { -F, 0, 0 },{  0,-E, 0 },{ +F, 0, 0 },{  0, 0,-E } };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

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

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

      }

    else if( variant==1 )

      {

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

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

      }

    else if( variant==2 )

      {

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

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

      }

    else

      {

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

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 || variant==1 )

      {

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

      float G = (1-REX_D)*SQ2/2;

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

      float[][] bands= { { height,10,G/3,0.5f,5,1,1},{ 0.001f,45,0.1f,0.1f,2,0,0} };

      return new ObjectFaceShape(bands,indices,null);

      }

    else if( variant==2 )

      {

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

      float G = 3*REX_D;

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

      float[][] bands= { {height,10,G/2,0.5f,5,0,0},{0.001f,45,G/2,0.0f,2,0,0} };

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

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

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

      float E = 1.5f - 3*REX_D;

      float F = 1.5f;

      float G = (float)Math.sqrt(E*E+F*F);

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

      float[][] bands= { {h1,12,F/3,0.8f,5,2,3},{h2,45,G/3,0.2f,5,2,3} };

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 || variant==1 )

      {

      float[][] centers= { {0.0f,0.0f,(REX_D-1)*SQ2/2} };

      float[][] corners= { {0.03f,0.30f} };

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

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

      }

    else if( variant==2 )

      {

      return null;

      }

    else

      {

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

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

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

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

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 4;

    }

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

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

    {

    return cubit<12 ? 0 : (cubit<24 ? 1 : (cubit<30?2:3));

    }

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

  public float getStickerRadius()

    {

    return 0.09f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.25f : 0.12f;

    }

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

  public float[][] getStickerAngles()

    {

    final float F = (float)(Math.PI/20);

    return new float[][] { { F,-F/2,F },{0,0,0,0},{ -F,0,-F } };

    }

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

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

    {

    return ObjectType.REX_3.name();

    }

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

  public ObjectSignature getSignature()

    {

    return new ObjectSignature(ObjectSignatures.REX_3);

    }

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

  public String getObjectName()

    {

    return "Rex Cube";

    }

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

  public String getInventor()

    {

    return "Andrew Cormier";

    }

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

  public int getYearOfInvention()

    {

    return 2009;

    }

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

  public int getComplexity()

    {

    return 3;

    }

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

  public String[][] getTutorials()

    {

    return new String[][]{

                          {"gb","noAQfWqlMbk","Rex Cube Tutorial","CrazyBadCuber"},

                          {"es","Q90x9rjLJzw","Resolver Cubo Rex","Cuby"},

                          {"ru","Dr9CLM6A3fU","Как собрать Рекс Куб","Алексей Ярыгин"},

                          {"fr","SvK1kf6c43c","Résolution du Rex Cube","Asthalis"},

                          {"de","AI4vtwpRkEQ","Rex Cube - Tutorial","GerCubing"},

                          {"pl","ffbFRnHglWY","Rex Cube TUTORIAL PL","MrUk"},

                          {"kr","B3ftZzHRQyU","렉스 큐브 해법","듀나메스 큐브 해법연구소"},

                          {"vn","5nE9Q7QmOP4","Tutorial N.87 - Rex Cube","Duy Thích Rubik"},

                         };

    }

}