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 static org.distorted.objectlib.touchcontrol.TouchControl.TC_OCTAHEDRON;

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

import java.io.InputStream;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.touchcontrol.TouchControlOctahedron;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.scrambling.ScrambleState;

import org.distorted.objectlib.main.ShapeOctahedron;

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

public class TwistyDiamond extends ShapeOctahedron

{

  // the four rotation axis of a Diamond. Must be normalized.

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(+SQ6/3,+SQ3/3,     0),

           new Static3D(-SQ6/3,+SQ3/3,     0),

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

           new Static3D(     0,-SQ3/3,+SQ6/3)

         };

  private ScrambleState[] mStates;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private int[] mTetraToFaceMap;

  private float[][] mPosition;

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

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

    {

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

    }

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

  public ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int[] numLayers = getNumLayers();

      int numL = numLayers[0];

      int[] tmp = new int[3*2*numL];

      for(int i=0; i<2*numL; i++)

        {

        tmp[3*i  ] = (i<numL) ?  i:i-numL;

        tmp[3*i+1] = (i%2==0) ? -1:1;

        tmp[3*i+2] = 0;

        }

      mStates = new ScrambleState[]

        {

        new ScrambleState( new int[][] {tmp,tmp,tmp,tmp} )

        };

      }

    return mStates;

    }

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

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

    {

    int numL = numLayers[0];

    if( numL<2 ) return null;

    if( mCuts==null )

      {

      mCuts = new float[4][numL-1];

      float cut = (SQ6/6)*(2-numL);

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

        {

        mCuts[0][i] = cut;

        mCuts[1][i] = cut;

        mCuts[2][i] = cut;

        mCuts[3][i] = cut;

        cut += SQ6/3;

        }

      }

    return mCuts;

    }

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

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

    {

    int numAxis = ROT_AXIS.length;

    boolean[][] layerRotatable = new boolean[numAxis][];

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

      {

      layerRotatable[i] = new boolean[numLayers[i]];

      for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;

      }

    return layerRotatable;

    }

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

  public int getTouchControlType()

    {

    return TC_OCTAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

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

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlOctahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlOctahedron.FACE_AXIS;

    }

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

  private int getNumOctahedrons(int layers)

    {

    return layers==1 ? 1 : 4*(layers-1)*(layers-1) + 2;

    }

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

  private int getNumTetrahedrons(int layers)

    {

    return 4*layers*(layers-1);

    }

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

  private int createOctaPositions(float[][] centers, int index, int layers, float height)

    {

    float x = (layers-1)*0.5f;

    float z = (layers+1)*0.5f;

    for(int i=0; i<layers; i++, index++)

      {

      z -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-1; i++, index++)

      {

      x -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-1; i++, index++)

      {

      z += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-2; i++, index++)

      {

      x += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    return index;

    }

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

  private int createTetraPositions(float[][] centers, int index, int layers, float height)

    {

    float x = (layers-1)*0.5f;

    float z =  layers*0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      z -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x += 0.5f;

    z -= 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      x -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x -= 0.5f;

    z -= 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      z += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x -= 0.5f;

    z += 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      x += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    return index;

    }

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

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

    {

    if( mPosition==null )

      {

      int layers = numLayers[0];

      int numO = getNumOctahedrons(layers);

      int numT = getNumTetrahedrons(layers);

      int index = 0;

      float height = 0.0f;

      mPosition = new float[numO+numT][3];

      index = createOctaPositions(mPosition,index,layers,height);

      for(int i=layers-1; i>0; i--)

        {

        height += SQ2/2;

        index = createOctaPositions(mPosition,index,i,+height);

        index = createOctaPositions(mPosition,index,i,-height);

        }

      height = SQ2/4;

      for(int i=layers; i>1; i--)

        {

        index = createTetraPositions(mPosition,index,i,+height);

        index = createTetraPositions(mPosition,index,i,-height);

        height += SQ2/2;

        }

      }

    return mPosition;

    }

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

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

    {

    int numL = numLayers[0];

    int numO = getNumOctahedrons(numL);

    if( cubit<numO ) return mObjectQuats[0];

    switch( retFaceTetraBelongsTo(cubit-numO, numL) )

      {

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

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

      case 2: return mObjectQuats[10];                  // 180 along Y

      case 3: return new Static4D(0,+SQ2/2,0,SQ2/2);    //  90 along

      case 4: return new Static4D(0,     0,1,    0);    // 180 along Z

      case 5: return mObjectQuats[4];

      case 6: return new Static4D(     1,0,0,    0);    // 180 along X

      case 7: return mObjectQuats[3];

      }

    return null;

    }

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

  private int retFaceTetraBelongsTo(int tetra, int numLayers)

    {

    if( mTetraToFaceMap==null ) mTetraToFaceMap = new int[] {1,2,3,0,5,6,7,4};

    for(int i=numLayers-1; i>0; i--)

      {

      if( tetra < 8*i ) return mTetraToFaceMap[tetra/i];

      tetra -= 8*i;

      }

    return -1;

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==0 )

      {

      float[][] vertices =

          {

             { 0.5f,  0.0f, 0.5f},

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

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

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

             { 0.0f, SQ2/2, 0.0f},

             { 0.0f,-SQ2/2, 0.0f}

          };

      int[][] indices =

          {

             {3,0,4},

             {0,1,4},

             {1,2,4},

             {2,3,4},

             {5,0,3},

             {5,1,0},

             {5,2,1},

             {5,3,2}

          };

      return new ObjectShape(vertices, indices);

      }

    else

      {

      float[][] vertices= { {-0.5f, SQ2/4, 0.0f}, { 0.5f, SQ2/4, 0.0f}, { 0.0f,-SQ2/4, 0.5f}, { 0.0f,-SQ2/4,-0.5f} };

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

      return new ObjectShape(vertices, indices);

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int numL = getNumLayers()[0];

    int N = numL>3 ? 5:6;

    int E = numL>2 ? (numL>3 ? 0:1) : 2;

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

    if( variant==0 )

      {

      float[][] bands     = { {height,20,0.5f,0.8f,N,E,E} };

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

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

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

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

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

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

      }

    else

      {

      float[][] bands     = { {height,35,0.5f,0.8f,N,E,E} };

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

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

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

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

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

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

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 2;

    }

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

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

    {

    return cubit<getNumOctahedrons(numLayers[0]) ? 0 : 1;

    }

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

  public float getStickerRadius()

    {

    return 0.08f;

    }

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

  public float getStickerStroke()

    {

    float stroke = 0.08f;

    if( isInIconMode() )

      {

      int[] numLayers = getNumLayers();

      switch(numLayers[0])

        {

        case 2: stroke*=1.4f; break;

        case 3: stroke*=2.0f; break;

        case 4: stroke*=2.1f; break;

        default:stroke*=2.2f; break;

        }

      }

    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 ObjectType.DIAM_2.name();

      case 3: return ObjectType.DIAM_3.name();

      case 4: return ObjectType.DIAM_4.name();

      }

    return ObjectType.DIAM_2.name();

    }

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

  public ObjectSignature getSignature()

    {

    switch(getNumLayers()[0])

      {

      case 2: return new ObjectSignature(ObjectType.DIAM_2);

      case 3: return new ObjectSignature(ObjectType.DIAM_3);

      case 4: return new ObjectSignature(ObjectType.DIAM_4);

      }

    return null;

    }

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

  public String getObjectName()

    {

    switch(getNumLayers()[0])

      {

      case 2: return "Skewb Diamond";

      case 3: return "Face Turning Octahedron";

      case 4: return "Master Face Turning Octahedron";

      }

    return "Skewb Diamond";

    }

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

  public String getInventor()

    {

    switch(getNumLayers()[0])

      {

      case 2: return "Uwe Meffert";

      case 3: return "David Pitcher";

      case 4: return "Timur Evbatyrov";

      }

    return "Uwe Meffert";

    }

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

  public int getYearOfInvention()

    {

    switch(getNumLayers()[0])

      {

      case 2: return 1984;

      case 3: return 2003;

      case 4: return 2011;

      }

    return 1984;

    }

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

  public int getComplexity()

    {

    switch(getNumLayers()[0])

      {

      case 2: return 1;

      case 3: return 3;

      case 4: return 4;

      }

    return 0;

    }

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

  public String[][] getTutorials()

    {

    int[] numLayers = getNumLayers();

    switch(numLayers[0])

      {

      case 2: return new String[][] {

                          {"gb","R2wrbJJ3izM","How to Solve a Skewb Diamond","Dr. Penguin^3"},

                          {"es","2RCusYQdYYE","Como resolver Skewb Diamond","Tutoriales Rubik"},

                          {"ru","k8B6RFcNoGw","Как собрать Skewb Diamond","Алексей Ярыгин"},

                          {"fr","tqbkgwNcZCE","Comment résoudre le Skewb Diamond","Valentino Cube"},

                          {"de","6ewzrCOnZfg","Octagon lösen","JamesKnopf"},

                          {"pl","61_Z4TpLMBc","Diamond Skewb TUTORIAL PL","MrUk"},

                          {"br","UapwpXMYtH4","Como resolver o Octaedro Diamond","Rafael Cinoto"},

                          {"kr","hVBSlfHVTME","공식 하나만 사용 - 다이아몬드 스큐브","Denzel Washington"},

                         };

      case 3: return new String[][] {

                          {"gb","n_mBSUDLUZw","Face Turning Octahedron Tutorial","SuperAntoniovivaldi"},

                          {"es","ogf0t6fGxZI","FTO - Tutorial en español","Gadi Rubik"},

                          {"ru","VXCjk0bVRoA","Как собрать Face Turning Octahedron","Алексей Ярыгин"},

                          {"de","6bO0AcwY5K8","Face Turning Octahedron - Tutorial","GerCubing"},

                          {"pl","huWg-ZfP-KY","Octahedron cube TUTORIAL PL","MrUk"},

                          {"br","WN3BoP4EbvM","Como resolver o octaedro 3x3 1/3","Rafael Cinoto"},

                          {"br","4zFlfANOliE","Como resolver o octaedro 3x3 2/3","Rafael Cinoto"},

                          {"br","6OvNzoHk7RU","Como resolver o octaedro 3x3 3/3","Rafael Cinoto"},

                          {"vn","KzGQ-mVRsss","Tutorial N.43 - FTO","Duy Thích Rubik"},

                         };

      case 4: return new String[][] {

                          {"gb","3GJkySk5zeQ","Master Face Turning Octahedron","SuperAntoniovivaldi"},

                          {"gb","zW_1htxy52k","Master FTO Tutorial","Michele Regano"},

                          {"es","3K8XL9SBSvs","Tutorial Master FTO de Mf8","Robert Cubes"},

                          {"ru","0CRwhZ2JNJA","Как собрать Master FTO","Алексей Ярыгин"},

                          {"vn","4XdeuGYDCJo","Tutorial N.141 - Master FTO","Duy Thích Rubik"},

                         };

      }

    return null;

    }

}