TwistyPuzzleLib

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

// Copyright 2020 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.objectlib.objects;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.scrambling.ScrambleState;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.main.ShapeOctahedron;

import org.distorted.objectlib.touchcontrol.TouchControlOctahedron;

import java.io.InputStream;

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

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

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

public class TwistyTrajber extends ShapeOctahedron

{

  // Trajber 3x3: each cut is at 1/5 of the length of the segment from the center to a vertex.

  private static final float CUT3 = 0.20f;

  // Trajber 4x4: each cut is at 1/4 of the length of the segment from the center to a vertex.

  private static final float CUT4 = 0.25f;

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

         new Static3D(SQ2/2, 0, SQ2/2),

         new Static3D(    0, 1,     0),

         new Static3D(SQ2/2, 0,-SQ2/2)

         };

  private ScrambleState[] mStates;

  private int[] mBasicAngle;

  private float[][] mCuts;

  private float[][] mCenters;

  private int[] mQuatIndex;

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

  public TwistyTrajber(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(numL, meshState, numL[0], quat, move, scale, stream);

    }

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

// TODO: override of the getSolvedQuats() - notice the 4x4 has multiple solved states!

  public ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int[][] m = new int[16][];

      for(int i=0; i<16; i++) m[i] = new int[] { 0,-1,i,0,1,i,0,2,i, 1,-1,i,1,1,i,1,2,i, 2,-1,i,2,1,i,2,2,i};

      mStates = new ScrambleState[]

          {

          new ScrambleState( new int[][] { m[ 1], m[ 2], m[ 3] } ),  //  0 0

          new ScrambleState( new int[][] {  null, m[ 4], m[ 5] } ),  //  1 x

          new ScrambleState( new int[][] { m[ 6],  null, m[ 7] } ),  //  2 y

          new ScrambleState( new int[][] { m[ 8], m[ 9],  null } ),  //  3 z

          new ScrambleState( new int[][] { m[10],  null, m[ 7] } ),  //  4 xy

          new ScrambleState( new int[][] { m[11], m[ 9],  null } ),  //  5 xz

          new ScrambleState( new int[][] {  null, m[12], m[ 5] } ),  //  6 yx

          new ScrambleState( new int[][] { m[ 8], m[13],  null } ),  //  7 yz

          new ScrambleState( new int[][] {  null, m[ 4], m[14] } ),  //  8 zx

          new ScrambleState( new int[][] { m[ 6],  null, m[15] } ),  //  9 zy

          new ScrambleState( new int[][] {  null,  null, m[ 5] } ),  // 10 xyx

          new ScrambleState( new int[][] {  null, m[ 4],  null } ),  // 11 xzx

          new ScrambleState( new int[][] {  null,  null, m[ 7] } ),  // 12 yxy

          new ScrambleState( new int[][] { m[ 6],  null,  null } ),  // 13 yzy

          new ScrambleState( new int[][] {  null, m[ 9],  null } ),  // 14 zxz

          new ScrambleState( new int[][] { m[ 8],  null,  null } ),  // 15 zyz

          };

      }

    return mStates;

    }

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

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

    {

    if( mCuts==null )

      {

      float[] tmp;

      if( numLayers[0]==3 )

        {

        final float cut= CUT3*numLayers[0]*SQ2/2;

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

        }

      else

        {

        final float cut= CUT4*numLayers[0]*SQ2/2;

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

        }

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

      }

    return mCuts;

    }

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

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

    {

    int numL = numLayers[0];

    boolean[] tmp = new boolean[numL];

    for(int i=0; i<numL; i++) tmp[i] = true;

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

    }

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

  public int getTouchControlType()

    {

    return TC_OCTAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

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

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlOctahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlOctahedron.FACE_AXIS;

    }

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

// TODO: support numLayers=4

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

    {

    if( mCenters==null )

      {

      float LEN = numLayers[0]*0.5f;

      mCenters = new float[][]

          {

              {   LEN,       0,   LEN},

              {  -LEN,       0,  -LEN},

              {     0, SQ2*LEN,     0},

              {     0,-SQ2*LEN,     0},

              {  -LEN,       0,   LEN},

              {   LEN,       0,  -LEN},

              {-LEN/2, (SQ2/2)*LEN, LEN/2},

              { LEN/2, (SQ2/2)*LEN,-LEN/2},

              {-LEN/2,-(SQ2/2)*LEN, LEN/2},

              { LEN/2,-(SQ2/2)*LEN,-LEN/2},

              {     0,     0,   LEN},

              {   LEN,     0,     0},

              {  -LEN,     0,     0},

              {     0,     0,  -LEN},

              { LEN/2, (SQ2/2)*LEN, LEN/2},

              { LEN/2,-(SQ2/2)*LEN, LEN/2},

              {-LEN/2, (SQ2/2)*LEN,-LEN/2},

              {-LEN/2,-(SQ2/2)*LEN,-LEN/2},

              {       0, SQ2*LEN/3, 2*LEN/3},

              { 2*LEN/3, SQ2*LEN/3,       0},

              {       0,-SQ2*LEN/3, 2*LEN/3},

              { 2*LEN/3,-SQ2*LEN/3,       0},

              {-2*LEN/3, SQ2*LEN/3,       0},

              {       0, SQ2*LEN/3,-2*LEN/3},

              {-2*LEN/3,-SQ2*LEN/3,       0},

              {       0,-SQ2*LEN/3,-2*LEN/3},

          };

      }

    return mCenters;

    }

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

// TODO: support numLayers=4

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

    {

    if( mQuatIndex==null ) mQuatIndex = new int[] {6,4,1,3,0,2, 7,19,9,18, 0,2,8,5, 1,3,14,11, 0,1,3,2,7,5,8,16 };

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

// TODO: support numLayers=4

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      final float LEN = getNumLayers()[0]*0.5f;

      final float A = SQ2*CUT3*LEN;

      final float B =     CUT3*LEN;

      float[][] vertices =

          {

             {    0,    0,    0},

             {    B,    A,   -B},

             {    B,   -A,   -B},

             {  2*B,    0,    0},

             {    0,    0, -2*B},

             {  3*B,    A,   -B},

             {  3*B,   -A,   -B},

             {    B,    A, -3*B},

             {    B,   -A, -3*B},

             {  LEN      ,    A, SQ2*A-LEN},

             {  LEN      ,   -A, SQ2*A-LEN},

             {  LEN-SQ2*A,    A,      -LEN},

             {  LEN-SQ2*A,   -A,      -LEN}

          };

      int[][] indices =

          {

             {0,3,5,1},

             {0,2,6,3},

             {0,4,8,2},

             {0,1,7,4},

             {3,6,10,9,5},

             {2,8,12,10,6},

             {4,7,11,12,8},

             {1,5,9,11,7},

             {9,10,12,11}

          };

      return new ObjectShape(vertices, indices);

      }

    if( variant==1 )

      {

      final float LEN = getNumLayers()[0]*0.5f;

      final float A = SQ2*CUT3*LEN;

      final float B = LEN*(1-2*CUT3);

      final float C = (SQ2/2)*A;

      float[][] vertices =

          {

             {    -B, 0,  0 },

             {  -B+C, A, -C },

             {  -B+C,-A, -C },

             {     B, 0,  0 },

             {   B-C, A, -C },

             {   B-C,-A, -C },

             {     0, A, -B },

             {     0,-A, -B },

          };

      int[][] indices =

          {

             {0,3,4,1},

             {0,2,5,3},

             {1,4,6},

             {2,7,5},

             {0,1,6,7,2},

             {3,5,7,6,4}

          };

      return new ObjectShape(vertices, indices);

      }

    else

      {

      final float LEN = getNumLayers()[0]*0.5f;

      final float L = LEN*(1-3*CUT3);

      float[][] vertices =

          {

             { -L, -(SQ2/3)*L,   L/3 },

             {  L, -(SQ2/3)*L,   L/3 },

             {  0,(2*SQ2/3)*L,-2*L/3 },

             {  0, -(SQ2/3)*L,-2*L/3 },

          };

      int[][] indices =

          {

             {0,1,2},

             {3,1,0},

             {0,2,3},

             {1,3,2},

          };

      return new ObjectShape(vertices, indices);

      }

    }

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

// TODO: support numLayers=4

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    final float LEN = getNumLayers()[0]*0.5f;

    if( variant==0 )

      {

      float[][] bands     = { {0.05f,35,0.15f,0.3f,4,1,1},{0.00f,35,0.15f,0.3f,4,1,1} };

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

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

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

      float[][] centers   = { { LEN/2, 0.0f, -LEN/2} };

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

      return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);

      }

    if( variant==1 )

      {

      final float B = LEN*(1-2*CUT3);

      float[][] bands     = { {0.03f,35,0.15f,0.3f,3,1,1},{0.00f,35,0.15f,0.3f,3,1,1} };

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

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

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

      float[][] centers   = { { 0, 0, -B} };

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

      return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);

      }

    else

      {

      final float L = LEN*(1-3*CUT3);

      float[][] bands     = { {0.03f,35,0.15f,0.3f,4,1,1},{0.00f,35,0.15f,0.3f,4,0,0} };

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

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

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

      float[][] centers   = { {0, -(SQ2/3)*L,-2*L/3} };

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

      return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,null);

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 3;

    }

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

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

    {

    if( numLayers[0]==3 ) return cubit< 6 ? 0 : cubit<18 ? 1 : 2;

    else                  return cubit<24 ? 0 : cubit<48 ? 1 : 2;

    }

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

  public float getStickerRadius()

    {

    return 0.12f;

    }

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

  public float getStickerStroke()

    {

    return ObjectControl.isInIconMode() ? 0.20f : 0.10f;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[] getBasicAngles()

    {

    if( mBasicAngle ==null ) mBasicAngle = new int[] { 4,4,4 };

    return mBasicAngle;

    }

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

  public String getShortName()

    {

    int[] numLayers = getNumLayers();

    return numLayers[0]==3 ? ObjectType.TRAJ_3.name() : ObjectType.TRAJ_4.name();

    }

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

  public long getSignature()

    {

    int[] numLayers = getNumLayers();

    return numLayers[0]==3 ? ObjectType.TRAJ_3.ordinal() : ObjectType.TRAJ_4.ordinal();

    }

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

  public String getObjectName()

    {

    int[] numLayers = getNumLayers();

    return numLayers[0]==3 ? "Trajber's Octahedron" : "Trajber 4x4";

    }

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

  public String getInventor()

    {

    int[] numLayers = getNumLayers();

    return numLayers[0]==3 ? "Josef Trajber" : "Jürgen Brandt";

    }

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

  public int getYearOfInvention()

    {

    int[] numLayers = getNumLayers();

    return numLayers[0]==3 ? 1982 : 2001;

    }

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

  public int getComplexity()

    {

    int[] numLayers = getNumLayers();

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

    }

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

  public String[][] getTutorials()

    {

    int[] numLayers = getNumLayers();

    switch(numLayers[0])

      {

      case 3: return new String[][] {

                                     {"gb","Q2NSiuJWVvk","Trajber and UFO Tutorial","SuperAntoniovivaldi"},

                                     {"es","FPBirEJ8ZfY","Resolver Octaedro 3x3","Solución Rubik"},

                                     {"de","FjQXlwJGniQ","Trajbers Octahedron Tutorial","GerCubing"},

                                     {"br","kO3nMpZKv3Q","Resolver Octaedro Trajber","Rafael Cinoto"},

                                    };

      case 4: return new String[][] {

                                     {"gb","FZlw68I7snM","4x4 Trajber's Tutorial (1/3)","SuperAntoniovivaldi"},

                                     {"gb","VM0XFu7gAII","4x4 Trajber's Tutorial (2/3)","SuperAntoniovivaldi"},

                                     {"es","Q8ljV-feLpU","Tutorial Octaedro 4x4 (1/2)","Dany Cuber"},

                                     {"es","QyWpDLa1eZQ","Tutorial Octaedro 4x4 (2/2)","Dany Cuber"},

                                     {"ru","ikUogVow-58","Как собрать Октаэдр 4х4","RBcuber"},

                                     {"fr","4hxZyMVGiTA","Résolution de l'Octaèdre 4x4","asthalis"},

                                     {"pl","oPBvAT9lwt4","Octahedron 4x4 TUTORIAL PL","MrUK"},

                                     {"br","0ZgaoQ6IS2w","Resolver o octaedro Trajber 4x4 (1/3)","Rafael Cinoto"},

                                     {"br","TjxTx3IJy6M","Resolver o octaedro Trajber 4x4 (2/3)","Rafael Cinoto"},

                                     {"br","E8k2TXfUS8g","Resolver o octaedro Trajber 4x4 (3/3)","Rafael Cinoto"},

                                     {"vn","yorULpIm6Yw","Tutorial N.22 - Octahedron 4x4","Duy Thích Rubik"},

                                    };

      }

    return null;

    }

}