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.metadata.Metadata;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

import org.distorted.objectlib.metadata.ListObjects;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.shape.ShapeHexahedron;

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

public class TwistySkewb extends ShapeHexahedron

{

  public 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[][] mPositions;

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

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

    {

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

    }

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

  @Override

  public float[][] returnRotationFactor()

    {

    int numL = getNumLayers()[0];

    float[] f = new float[numL];

    for(int i=0; i<numL; i++) f[i] = 1.7f;

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

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null ) mEdges = ScrambleEdgeGenerator.getScrambleEdgesSingle(mBasicAngle);

    return mEdges;

    }

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

  private int getNumCorners()

    {

    return 8;

    }

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

  private int getNumEdges(int numLayers)

    {

    return (numLayers-2)*12;

    }

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

  private int getNumCentersPerFace(int numLayers)

    {

    return ((numLayers-2)*(numLayers-2) + (numLayers-1)*(numLayers-1));

    }

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

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

    {

    if( mCuts==null )

      {

      float[] c = numLayers[0]==2 ? (new float[] {0.0f}) : (new float[] {-SQ3/6, SQ3/6});

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

      }

    return mCuts;

    }

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

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

    {

    boolean[] tmp = numLayers[0]==2 ? (new boolean[] {true,true}) : (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( mPositions==null )

      {

      int numL = numLayers[0];

      final float DIST_CORNER = numL-1;

      final float DIST_EDGE   = numL-1;

      final float DIST_CENTER = numL-1;

      final int numCorners = getNumCorners();

      final int numEdges   = getNumEdges(numL);

      final int numCenters = 6*getNumCentersPerFace(numL);

      mPositions = new float[numCorners+numEdges+numCenters][];

      /// CORNERS //////////////////////////////////////////////

      mPositions[0] = new float[] { DIST_CORNER, DIST_CORNER, DIST_CORNER };

      mPositions[1] = new float[] { DIST_CORNER, DIST_CORNER,-DIST_CORNER };

      mPositions[2] = new float[] { DIST_CORNER,-DIST_CORNER, DIST_CORNER };

      mPositions[3] = new float[] { DIST_CORNER,-DIST_CORNER,-DIST_CORNER };

      mPositions[4] = new float[] {-DIST_CORNER, DIST_CORNER, DIST_CORNER };

      mPositions[5] = new float[] {-DIST_CORNER, DIST_CORNER,-DIST_CORNER };

      mPositions[6] = new float[] {-DIST_CORNER,-DIST_CORNER, DIST_CORNER };

      mPositions[7] = new float[] {-DIST_CORNER,-DIST_CORNER,-DIST_CORNER };

      /// CENTERS //////////////////////////////////////////////

      int index=8;

      final float X= -1000.0f;

      final float Y= -1001.0f;

      final float[][]  centerTable =

        {

            {X,Y,+DIST_CENTER},

            {X,Y,-DIST_CENTER},

            {X,+DIST_CENTER,Y},

            {X,-DIST_CENTER,Y},

            {+DIST_CENTER,X,Y},

            {-DIST_CENTER,X,Y},

        };

      float x,y, cen0, cen1, cen2;

      for( float[] centers : centerTable )

        {

        x = 2-numL;

        for(int i=0; i<numL-1; i++, x+=2)

          {

          y = 2-numL;

          for(int j=0; j<numL-1; j++, y+=2, index++)

            {

                 if( centers[0]==Y ) cen0 = y;

            else if( centers[0]==X ) cen0 = x;

            else                     cen0 = centers[0];

                 if( centers[1]==Y ) cen1 = y;

            else if( centers[1]==X ) cen1 = x;

            else                     cen1 = centers[1];

                 if( centers[2]==Y ) cen2 = y;

            else if( centers[2]==X ) cen2 = x;

            else                     cen2 = centers[2];

            mPositions[index] = new float[] {cen0,cen1,cen2};

            }

          }

        x = 3-numL;

        for(int i=0; i<numL-2; i++, x+=2)

          {

          y = 3-numL;

          for(int j=0; j<numL-2; j++, y+=2, index++)

            {

                 if( centers[0]==Y ) cen0 = y;

            else if( centers[0]==X ) cen0 = x;

            else                     cen0 = centers[0];

                 if( centers[1]==Y ) cen1 = y;

            else if( centers[1]==X ) cen1 = x;

            else                     cen1 = centers[1];

                 if( centers[2]==Y ) cen2 = y;

            else if( centers[2]==X ) cen2 = x;

            else                     cen2 = centers[2];

            mPositions[index] = new float[] {cen0,cen1,cen2};

            }

          }

        }

      /// EDGES ///////////////////////////////////////////////

      final float[][]  edgeTable =

        {

            {0,+DIST_EDGE,+DIST_EDGE},

            {+DIST_EDGE,0,+DIST_EDGE},

            {0,-DIST_EDGE,+DIST_EDGE},

            {-DIST_EDGE,0,+DIST_EDGE},

            {+DIST_EDGE,+DIST_EDGE,0},

            {+DIST_EDGE,-DIST_EDGE,0},

            {-DIST_EDGE,-DIST_EDGE,0},

            {-DIST_EDGE,+DIST_EDGE,0},

            {0,+DIST_EDGE,-DIST_EDGE},

            {+DIST_EDGE,0,-DIST_EDGE},

            {0,-DIST_EDGE,-DIST_EDGE},

            {-DIST_EDGE,0,-DIST_EDGE}

        };

      for (float[] edges : edgeTable)

        {

        float c = 3-numL;

        for (int j=0; j<numL-2; j++, c+=2, index++)

          {

          mPositions[index] = new float[] { edges[0]==0 ? c : edges[0] ,

                                            edges[1]==0 ? c : edges[1] ,

                                            edges[2]==0 ? c : edges[2] };

          }

        }

      }

    return mPositions;

    }

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

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

    {

    int numL = numLayers[0];

    int numCorners = getNumCorners();

    int numCentersPerFace = getNumCentersPerFace(numL);

    int numCenters = 6*numCentersPerFace;

    if( cubit<numCorners )

      {

      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)

        }

      }

    else if( cubit<numCorners+numCenters )

      {

      int center = (cubit-numCorners)/numCentersPerFace;

      switch(center)

        {

        case 0: return mObjectQuats[0];

        case 1: return mObjectQuats[9];

        case 2: return mObjectQuats[1];

        case 3: return mObjectQuats[4];

        case 4: return mObjectQuats[2];

        case 5: return mObjectQuats[3];

        }

      }

    else

      {

      int edge = (cubit-numCorners-numCenters)/(numL-2);

      switch(edge)

        {

        case  0: return mObjectQuats[ 0];

        case  1: return mObjectQuats[ 2];

        case  2: return mObjectQuats[10];

        case  3: return mObjectQuats[ 8];

        case  4: return mObjectQuats[ 1];

        case  5: return mObjectQuats[ 4];

        case  6: return mObjectQuats[ 6];

        case  7: return mObjectQuats[ 7];

        case  8: return mObjectQuats[11];

        case  9: return mObjectQuats[ 5];

        case 10: return mObjectQuats[ 9];

        case 11: return mObjectQuats[ 3];

        }

      }

    return null;

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==0 )

      {

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

      }

    else if( variant==1 )

      {

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

      }

    else

      {

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

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

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

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

      }

    else if( variant==1 )

      {

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

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

      }

    else

      {

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

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

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int numL = getNumLayers()[0];

    if( variant==0 )

      {

      int N = numL==2 ? 7:5;

      int E1= numL==2 ? 3:2;

      int E2= numL==2 ? 5:3;

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

      float[][] bands = { {height,35,0.16f,0.7f,N,E1,E1}, {0.001f, 35,1.00f,0.0f,3,1,E2} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else if( variant==1 )

      {

      int N = numL==2 ? 7:6;

      int E = numL==2 ? 3:1;

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

      float[][] bands = { {height,35,SQ2/8,0.9f,N,E,E}, {0.001f,35,1,0.0f,3,0,0} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    else

      {

      int N = numL==2 ? 7:5;

      int E = numL==2 ? 5:2;

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

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

      float[][] bands = { {h1,30,0.16f,0.8f,N,2,E}, {h2,45,0.16f,0.2f,3,1,2} };

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

      return new ObjectFaceShape(bands,indices,null);

      }

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    if( variant==0 )

      {

      float[][] corners   = { {0.05f,0.25f}, {0.05f,0.20f} };

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

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

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

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

      }

    else if( variant==1 )

      {

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

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

      float[][] centers   = { {0,0,-0.4f} };

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

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

      }

    else

      {

      float[][] corners   = { {0.07f,0.20f}, {0.02f,0.30f} };

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

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

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

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

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return numLayers[0]==2 ? 2:3;

    }

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

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

    {

    return cubit<8 ? 0 : (cubit<8+6*getNumCentersPerFace(numLayers[0]) ? 1:2);

    }

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

  public float getStickerRadius()

    {

    return 0.08f;

    }

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

  public float getStickerStroke()

    {

    float stroke = 0.08f;

    if( isInIconMode() )

      {

      int[] numLayers = getNumLayers();

      stroke *= (numLayers[0]==2 ? 2.0f : 2.7f);

      }

    return stroke;

    }

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

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

    {

    switch(getNumLayers()[0])

      {

      case 2: return ListObjects.SKEW_2.name();

      case 3: return ListObjects.SKEW_3.name();

      }

    return ListObjects.SKEW_2.name();

    }

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

  public String[][] getTutorials()

    {

    int[] numLayers = getNumLayers();

    switch(numLayers[0])

      {

      case 2: return new String[][] {

                          {"gb","I6132yshkeU","How to Solve the Skewb","Z3"},

                          {"es","wxQX3HhPgds","Resolver Skewb (Principiantes)","Cuby"},

                          {"ru","EICw3aqn6Bc","Как собрать Скьюб?","Алексей Ярыгин"},

                          {"fr","lR-GuIroh4k","Comment réussir le skewb","Rachma Nikov"},

                          {"de","7RX6D5pznOk","Skewb lösen","Pezcraft"},

                          {"pl","ofRu1fByNpk","Jak ułożyć: Skewb","DżoDżo"},

                          {"br","mNycauwshWs","Como resolver o Skewb","Pedro Filho"},

                          {"kr","5R3sU-_bMAI","SKEWB 초보 공식","iamzoone"},

                          {"vn","Db5mXuqgQP8","Tutorial N.5 - Skewb","Duy Thích Rubik"},

                          {"tw","XtZL9WFMkA8","斜轉魔方教學","不正常魔術方塊研究中心"},

                         };

      case 3: return new String[][] {

                          {"gb","Jiuf7zQyPYI","Master Skewb Cube Tutorial","Bearded Cubing"},

                          {"es","8TP6p63KQCA","Master Skewb en Español","jorlozCubes"},

                          {"ru","7155QSp3T74","часть 1: Как собрать мастер Скьюб","Иван Циков"},

                          {"ru","14ey-RihjgY","часть 2: Как собрать мастер Скьюб","Иван Циков"},

                          {"ru","watq6TLa5_E","часть 2.5: Как собрать мастер Скьюб","Иван Циков"},

                          {"ru","UnsvseFBXmo","часть 3: Как собрать мастер Скьюб","Иван Циков"},

                          {"fr","tYMoY4EOHVA","Résolution du Master Skewb","Asthalis"},

                          {"de","LSErzqGNElI","Master Skewb lösen","JamesKnopf"},

                          {"pl","Y7l3AYFvDJI","Master Skewb TUTORIAL PL","MrUk"},

                          {"kr","ycR-WmXJCG0","마스터 스큐브 3번째 해법","듀나메스 큐브 해법연구소"},

                          {"vn","uG8H0ZQTZgw","Tutorial N.35 - Master Skewb","Duy Thích Rubik"},

                          {"tw","PAPa069Y92M","大師斜轉方塊 教學","不正常魔術方塊研究中心"},

                         };

      }

    return null;

    }

}