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 TwistyRedi 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)

         };

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPosition;

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

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

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      mEdges = new int[][]

        {

          { 0,8,1,8, 4,1,5,1, 6,7,7,7, 10,2,11,2, 12,6,13,6, 16,3,17,3, 18,5,19,5, 22,4,23,4 },  // 0

          {                            10,2,11,2,            16,3,17,3, 18,5,19,5            },  // 1

          {          4,1,5,1,                     12,6,13,6,                       22,4,23,4 },  // 2

          {          4,1,5,1, 6,7,7,7,                                             22,4,23,4 },  // 3

          { 0,8,1,8,                   10,2,11,2,            16,3,17,3                       },  // 4

          {          4,1,5,1, 6,7,7,7,            12,6,13,6                                  },  // 5

          { 0,8,1,8,                   10,2,11,2,                       18,5,19,5            },  // 6

          { 0,8,1,8,                                         16,3,17,3, 18,5,19,5            },  // 7

          {                   6,7,7,7,            12,6,13,6,                       22,4,23,4 },  // 8

        };

      }

    return mEdges;

    }

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

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

    {

    if( mCuts==null )

      {

      float C = SQ3/3 +0.05f;

      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 DIST_CORNER = 1.0f;

      final float DIST_EDGE   = 1.5f;

      mPosition = new float[][]

         {

             { DIST_CORNER, DIST_CORNER, DIST_CORNER },

             { DIST_CORNER, DIST_CORNER,-DIST_CORNER },

             { DIST_CORNER,-DIST_CORNER, DIST_CORNER },

             { DIST_CORNER,-DIST_CORNER,-DIST_CORNER },

             {-DIST_CORNER, DIST_CORNER, DIST_CORNER },

             {-DIST_CORNER, DIST_CORNER,-DIST_CORNER },

             {-DIST_CORNER,-DIST_CORNER, DIST_CORNER },

             {-DIST_CORNER,-DIST_CORNER,-DIST_CORNER },

             {      0.0f, DIST_EDGE, DIST_EDGE },

             { DIST_EDGE,      0.0f, DIST_EDGE },

             {      0.0f,-DIST_EDGE, DIST_EDGE },

             {-DIST_EDGE,      0.0f, DIST_EDGE },

             { DIST_EDGE, DIST_EDGE,      0.0f },

             { DIST_EDGE,-DIST_EDGE,      0.0f },

             {-DIST_EDGE,-DIST_EDGE,      0.0f },

             {-DIST_EDGE, DIST_EDGE,      0.0f },

             {      0.0f, DIST_EDGE,-DIST_EDGE },

             { DIST_EDGE,      0.0f,-DIST_EDGE },

             {      0.0f,-DIST_EDGE,-DIST_EDGE },

             {-DIST_EDGE,      0.0f,-DIST_EDGE }

         };

      }

    return mPosition;

    }

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

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

    {

    switch(cubit)

      {

      case  0: return mObjectQuats[0];                   //  unit quat

      case  1: return new Static4D( SQ2/2,0,0,SQ2/2);    //  90 along X

      case  2: return new Static4D(-SQ2/2,0,0,SQ2/2);    // -90 along X

      case  3: return mObjectQuats[9];                   // 180 along X

      case  4: return new Static4D(0, SQ2/2,0,SQ2/2);    //  90 along Y

      case  5: return mObjectQuats[11];                  // 180 along Y

      case  6: return mObjectQuats[10];                  // 180 along Z

      case  7: return new Static4D(SQ2/2,0,-SQ2/2,0);    // 180 along (SQ2/2,0,-SQ2/2)

      case  8: return mObjectQuats[0];

      case  9: return mObjectQuats[2];

      case 10: return mObjectQuats[10];

      case 11: return mObjectQuats[8];

      case 12: return mObjectQuats[1];

      case 13: return mObjectQuats[4];

      case 14: return mObjectQuats[6];

      case 15: return mObjectQuats[7];

      case 16: return mObjectQuats[11];

      case 17: return mObjectQuats[5];

      case 18: return mObjectQuats[9];

      case 19: return mObjectQuats[3];

      }

    return null;

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      return new float[][]

          {

             { 0.0f, 0.0f, 0.0f },

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

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

             { 0.5f, 0.5f, 0.5f },

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

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

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

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

          };

      }

    else

      {

      return new float[][]

          {

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

             { 0.5f, 0.0f, 0.0f},

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

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

             { 0.0f,-1.5f, 0.0f},

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

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

             { 0.0f, 0.0f,-1.5f},

          };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      int[][] indices =

          {

             { 2,4,3,1 },

             { 1,3,5,7 },

             { 4,6,5,3 },

             { 0,4,2 },

             { 0,7,5 },

             { 0,6,4 },

             { 0,1,7 },

             { 0,2,1 },

             { 0,5,6 }

          };

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

      }

    else

      {

      int[][] indices =

          {

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

             { 0,1,6,7,5 },

             { 1,3,6 },

             { 5,2,0 },

             { 4,7,6,3 },

             { 2,5,7,4 }

          };

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

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

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

      float[][] bands = { {h1,35,0.5f,0.7f,5,2,2}, {h2,35,0.2f,0.4f,5,2,2} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

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

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

      float[][] bands = { {h1,35,0.250f,0.7f,7,2,2}, {h2,35,0.125f,0.2f,3,1,2}, {h2,35,0.125f,0.2f,3,1,1} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

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

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

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

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

      }

    else

      {

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

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

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

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

    }

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

  public float getStickerRadius()

    {

    return 0.09f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.20f : 0.09f;

    }

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

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

    {

    return ObjectType.REDI_3.name();

    }

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

  public ObjectSignature getSignature()

    {

    return new ObjectSignature(ObjectSignatures.REDI_3);

    }

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

  public String getObjectName()

    {

    return "Redi Cube";

    }

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

  public String getInventor()

    {

    return "Oskar van Deventer";

    }

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

  public int getYearOfInvention()

    {

    return 2009;

    }

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

  public int getComplexity()

    {

    return 1;

    }

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

  public String[][] getTutorials()

    {

    return new String[][] {

                          {"gb","Qn7TJED6O-4","How to Solve the MoYu Redi Cube","Z3"},

                          {"es","g0M38Aotgac","Resolver Redi Cube","Cuby"},

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

                          {"fr","zw7UZcqqsgA","Comment résoudre le Redi Cube","ValentinoCube"},

                          {"de","YU8riouyC2w","Redi Cube Solve","CubaroCubing"},

                          {"pl","vxo3lXMsWQI","Jak ułożyć Redi Cube?","DJ rubiks"},

                          {"br","muQ8U_G4LmM","Como resolver o Redi Cube","Rafael Cinoto"},

                          {"kr","a5CzDMbRzbY","레디큐브를 배우기","vincentcube"},

                          {"vn","2JZxtmrKUn4","Tutorial N.6 - Redi","Duy Thích Rubik"},

                         };

    }

}