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

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

import java.io.InputStream;

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

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

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

public class TwistyVoid extends ShapeHexahedron

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private float[][] mPositions;

  private int[] mQuatIndex;

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

  public TwistyVoid(InitData data, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)

    {

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

    }

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

  @Override

  public void adjustStickerCoords()

    {

    final float A = 0.497f;

    final float B = 0.38950402f;

    final float C = 0.25900806f;

    final float D = 0.51f;

    mStickerCoords = new float[][]

          {

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

             { -C, -B, D, -B, D, B, -C, B }

          };

    }

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

  @Override

  public int getInternalColor()

    {

    return 0xff222222;

    }

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

  private void insertSection(int[] table, int startIndex, int size, int startAlg, int state)

    {

    for(int i=0; i<size; i++)

      {

      table[2*(i+startIndex)  ] = startAlg +i;

      table[2*(i+startIndex)+1] = state;

      }

    }

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

  private int[] createEdge(int stateX, int stateY, int stateZ)

    {

    int size = 8;

    int num = 0;

    if( stateX>=0 ) num += size;

    if( stateY>=0 ) num += size;

    if( stateZ>=0 ) num += size;

    int[] ret = new int[2*num];

    if( stateX>=0 )

      {

      insertSection(ret,0,size,0,stateX);

      if( stateY>=0 )

        {

        insertSection(ret,size,size,size+1,stateY);

        if( stateZ>=0 ) insertSection(ret,2*size,size,2*size+2,stateZ);

        }

      else

        {

        if( stateZ>=0 ) insertSection(ret,size,size,2*size+2,stateZ);

        }

      }

    else

      {

      if( stateY>=0 )

        {

        insertSection(ret,0,size,size+1,stateY);

        if( stateZ>=0 ) insertSection(ret,size,size,2*size+2,stateZ);

        }

      else

        {

        if( stateZ>=0 ) insertSection(ret,0,size,2*size+2,stateZ);

        }

      }

    return ret;

    }

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

// Normal 3x3, but without the 180 deg move of the middle layer.

// We need to rotate the middle layer here (by swiping it is not possible) because otherwise the

// phantom centers would always stay at their initial positions which would defeat the point here.

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      mEdges = new int[][]

        {

        createEdge( 1, 2, 3), // 0 0

        createEdge(-1, 4, 5), // 1 x

        createEdge( 6,-1, 7), // 2 y

        createEdge( 8, 9,-1), // 3 z

        createEdge(10,-1, 7), // 4 xy

        createEdge(11, 9,-1), // 5 xz

        createEdge(-1,12, 5), // 6 yx

        createEdge( 8,13,-1), // 7 yz

        createEdge(-1, 4,14), // 8 zx

        createEdge( 6,-1,15), // 9 zy

        createEdge(-1,-1, 5), // 10 xyx

        createEdge(-1, 4,-1), // 11 xzx

        createEdge(-1,-1, 7), // 12 yxy

        createEdge( 6,-1,-1), // 13 yzy

        createEdge(-1, 9,-1), // 14 zxz

        createEdge( 8,-1,-1), // 15 zyz

        };

      }

    return mEdges;

    }

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

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

    {

    if( mCuts==null )

      {

      float C = 0.5f;

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

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

      }

    return mCuts;

    }

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

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

    {

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

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

    }

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

  public int getTouchControlType()

    {

    return TC_HEXAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][] { {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}} };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlHexahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

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

    {

    if( mPositions==null )

      {

      mPositions = new float[][]

         {

             { 1.0f, 1.0f, 1.0f},

             { 1.0f, 1.0f,-1.0f},

             { 1.0f,-1.0f, 1.0f},

             { 1.0f,-1.0f,-1.0f},

             {-1.0f, 1.0f, 1.0f},

             {-1.0f, 1.0f,-1.0f},

             {-1.0f,-1.0f, 1.0f},

             {-1.0f,-1.0f,-1.0f},

             { 1.0f, 1.0f, 0.0f},

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

             { 1.0f, 0.0f, 1.0f},

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

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

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

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

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

             { 0.0f, 1.0f, 1.0f},

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

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

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

         };

      }

    return mPositions;

    }

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

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

    {

    if( mQuatIndex==null ) mQuatIndex = new int[] {0,1,17,22,4,5,8,19,  1,3,0,2,10,11,4,5,9,15,7,19 };

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

      final float X = 0.3f;

      final double A = 54*Math.PI/180;

      final float COS = (float)Math.cos(A);

      final float SIN = (float)Math.sin(A);

      return new float[][]

          {

              { -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 },

              { +0.5f, +0.5f, -0.5f+X },

              { +0.5f, -0.5f+X, +0.5f },

              { -0.5f+X, +0.5f, +0.5f },

              { SIN-0.5f, 0.5f, COS-0.5f },

              { COS-0.5f, 0.5f, SIN-0.5f },

              { COS-0.5f, SIN-0.5f, 0.5f },

              { SIN-0.5f, COS-0.5f, 0.5f },

              { 0.5f, COS-0.5f, SIN-0.5f },

              { 0.5f, SIN-0.5f, COS-0.5f },

          };

      }

    else

      {

      final float A = 0.13f;

      final float B = 0.18f;

      final float C = 0.52f;

      return new float[][]

          {

              {    C, 0.5f,    C},

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

              {    C,-0.5f,    C},

              { 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+A, 0.25f, 0.5f},

              {-0.5f+B, 0.00f, 0.5f},

              {-0.5f+A,-0.25f, 0.5f},

              {-0.5f+A, 0.25f,-0.5f+A},

              {-0.5f+B, 0.00f,-0.5f+B},

              {-0.5f+A,-0.25f,-0.5f+A},

              { 0.5f  , 0.25f,-0.5f+A},

              { 0.5f  , 0.00f,-0.5f+B},

              { 0.5f  ,-0.25f,-0.5f+A},

          };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )  // corner

      {

      int[][] indices =

          {

              {6,1,5,8,13,12,9},

              {5,3,4,7,15,14,8},

              {4,2,6,9,11,10,7},

              {0,1,6,2},

              {0,3,5,1},

              {0,2,4,3},

              {9,12,11},

              {8,14,13},

              {7,10,15},

              {10,11,12,13,14,15}

          };

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

      }

    else                // edge

      {

      int[][] indices =

          {

              {6,2,0,4,8,9,10},

              {1,0,2,3,16,15,14},

              {4,0,1,5},

              {2,6,7,3},

              {11,8,4,5},

              {12,9,8,11},

              {13,10,9,12},

              {7,6,10,13},

              {13,16,3,7},

              {12,15,16,13},

              {11,14,15,12},

              {5,1,14,11}

          };

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    if( variant==0 )

      {

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

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

      float h3 = isInIconMode() ? 0.001f : 0.030f;

      float[][] bands = { {h1,20,0.2f,0.4f,5,1,0}, {h2,5,0.3f,0.2f,5,0,0}, {h3,8,0.3f,0.2f,6,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

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

      float[][] bands = { {h1,5,0.2f,0.4f,5,1,0}, {0.001f,1,0.3f,0.5f,5,0,0}, {0.001f,1,0.3f,0.5f,5,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

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

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

      float[][] centers = { { -0.5f, -0.5f, -0.5f } };

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

      }

    else

      {

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

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

      float[][] centers = { { 0.0f, 0.0f, 0.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<8 ? 0:1;

    }

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

  public float getStickerRadius()

    {

    return 0.05f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.22f : 0.12f;

    }

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

  public float[][] getStickerAngles()

    {

    float D = (float)(Math.PI/6);

    return new float[][] { { 0,D,0 },{ 0,0,0,-D } };

    }

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

// 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] = 4;

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

      }

    return mBasicAngle;

    }

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

  public String getShortName()

    {

    return ObjectType.VOID_3.name();

    }

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

  public ObjectSignature getSignature()

    {

    return new ObjectSignature(ObjectType.VOID_3);

    }

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

  public String getObjectName()

    {

    return "Void Cube";

    }

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

  public String getInventor()

    {

    return "Katsuhiko Okamoto";

    }

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

  public int getYearOfInvention()

    {

    return 2012;

    }

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

  public int getComplexity()

    {

    return 2;

    }

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

  public String[][] getTutorials()

    {

    return new String[][]{

                          {"gb","3sLMpQrX_dU","How to Solve the Void Cube","Z3"},

                          {"gb","EB0bmcI1RnM","aVOIDing parity: Void Cube","SuperAntoniovivaldi"},

                          {"es","tDV4vmo7Qz4","Resolver 3x3 Void (Hueco)","Cuby"},

                          {"ru","BCa6Zh8-I_g","Как собрать Войд-Куб","RBcuber"},

                          {"fr","yqSyPu5ciAc","Résoudre le Void Cube","TwinsCuber"},

                          {"de","1mh-jRrcP0w","Void Cube: Parity intuitiv lösen","rofrisch"},

                          {"br","uTC01oMGBJ8","3x3 Void cube Tutorial","Cubo vicio"},

                          {"kr","eCfepw1gVBA","보이드 큐브(홀큐브)","듀나메스 큐브 해법연구소"},

                         };

    }

}