TwistyPuzzleLib

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

// Copyright 2021 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_TETRAHEDRON;

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.touchcontrol.TouchControlTetrahedron;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ScrambleState;

import org.distorted.objectlib.main.ShapeTetrahedron;

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

public class TwistyJing extends ShapeTetrahedron

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

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

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

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

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

         };

  static final float F = 0.48f;  // length of the edge of the corner cubit. Keep<0.5

                                 // Assuming the length of the edge of the whole

                                 // tetrahedron is 2.0 (ie standard, equal to numLayers)

  private ScrambleState[] mStates;

  private int[] mBasicAngle;

  private int[] mRotQuat;

  private Static4D[] mQuats;

  private float[][] mCuts;

  private float[][] mCenters;

  private int[][] mFaceMap;

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

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

    {

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

    }

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

  public ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

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

      mStates = new ScrambleState[]

        {

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

        };

      }

    return mStates;

    }

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

  private void initializeQuats()

    {

    mQuats = new Static4D[]

         {

         new Static4D(  0.0f,   0.0f,   0.0f,  1.0f),

         new Static4D(  0.0f,   1.0f,   0.0f,  0.0f),

         new Static4D( SQ2/2,   0.5f,   0.0f,  0.5f),

         new Static4D(-SQ2/2,   0.5f,   0.0f,  0.5f),

         new Static4D(  0.0f,  -0.5f, -SQ2/2,  0.5f),

         new Static4D(  0.0f,  -0.5f,  SQ2/2,  0.5f),

         new Static4D( SQ2/2,   0.5f,   0.0f, -0.5f),

         new Static4D(-SQ2/2,   0.5f,   0.0f, -0.5f),

         new Static4D(  0.0f,  -0.5f, -SQ2/2, -0.5f),

         new Static4D(  0.0f,  -0.5f,  SQ2/2, -0.5f),

         new Static4D( SQ2/2,   0.0f,  SQ2/2,  0.0f),

         new Static4D(-SQ2/2,   0.0f,  SQ2/2,  0.0f)

         };

    }

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

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

    {

    if( mQuats==null ) initializeQuats();

    int status = retCubitSolvedStatus(cubit,numLayers);

    return status<0 ? null : buildSolvedQuats(TouchControlTetrahedron.FACE_AXIS[status],mQuats);

    }

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

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

    {

    if( mCenters==null )

      {

      mCenters = new float[][]

         {

           { 0.000f, -SQ2/2, 1.000f },

           { 0.000f, -SQ2/2,-1.000f },

           {-1.000f,  SQ2/2, 0.000f },

           { 1.000f,  SQ2/2, 0.000f },

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

           {-0.500f, 0.000f, 0.500f },

           { 0.500f, 0.000f, 0.500f },

           {-0.500f, 0.000f,-0.500f },

           { 0.500f, 0.000f,-0.500f },

           { 0.000f,  SQ2/2, 0.000f },

           { 0.000f,  SQ2/6, 1.0f/3 },

           { 0.000f,  SQ2/6,-1.0f/3 },

           {-1.0f/3, -SQ2/6, 0.000f },

           { 1.0f/3, -SQ2/6, 0.000f },

         };

      }

    return mCenters;

    }

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

  public Static4D[] getQuats()

    {

    if( mQuats==null ) initializeQuats();

    return mQuats;

    }

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

  public int getSolvedFunctionIndex()

    {

    return 0;

    }

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

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

    {

    if( mCuts==null )

      {

      float[] cut = { (F-0.5f)*(SQ6/3) };

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

      }

    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_TETRAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

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

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return null;

    }

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

  public int getNumCubitFaces()

    {

    return 6;

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    final float X = F/2;

    final float Y = F*SQ2/2;

    final float Z =-F/2;

    final float L = (2.0f-3*F);

    final float X2= L/2;

    final float Y2= L*SQ2/2;

    final float Z2=-L/2;

    final float D = F/L;

    final float G = 1.0f-F;

    if( variant==0 )

      {

      float[][] vertices =

          {

             {   0,   0,   0 },

             {   X,   Y,   Z },

             {   0, 2*Y, 2*Z },

             {  -X,   Y,   Z },

             {   0,   0,    -F },

             {   X,   Y,   Z-F },

             {   0, 2*Y, 2*Z-F },

             {  -X,   Y,   Z-F },

          };

      int[][] indices =

          {

             {0,1,2,3},

             {1,0,4,5},

             {7,4,0,3},

             {1,5,6,2},

             {7,3,2,6},

             {4,7,6,5}

          };

      return new ObjectShape(vertices, indices, getNumCubitFaces(), 3);

      }

    else if( variant==1 )

      {

      float[][] vertices =

          {

             {   0,   0,     G },

             {   X,   Y,   Z+G },

             {   0, 2*Y, 2*Z+G },

             {  -X,   Y,   Z+G },

             {   0,   0,    -G },

             {   X,   Y,  -Z-G },

             {   0, 2*Y,-2*Z-G },

             {  -X,   Y,  -Z-G },

          };

      int[][] indices =

          {

             {0,4,5,1},

             {3,7,4,0},

             {0,1,2,3},

             {4,7,6,5},

             {1,5,6,2},

             {2,6,7,3}

          };

      return new ObjectShape(vertices, indices, getNumCubitFaces(), 2);

      }

    else

      {

      float[][] vertices =

          {

             {        0,   -2*Y2/3,       -2*Z2/3 },

             {       X2,      Y2/3,          Z2/3 },

             {      -X2,      Y2/3,          Z2/3 },

             {        0,   -2*Y2/3,-2*Z2/3+2*D*Z2 },

             {  X2-D*X2, Y2/3-D*Y2,     Z2/3+D*Z2 },

             { -X2+D*X2, Y2/3-D*Y2,     Z2/3+D*Z2 },

          };

      int[][] indices =

          {

             {0,1,2},

             {3,5,4},

             {0,3,4,1},

             {5,3,0,2},

             {4,5,2,1}

          };

      return new ObjectShape(vertices, indices, getNumCubitFaces(), 1);

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    final float Y = F*SQ2/2;

    final float Z =-F/2;

    final float L = (2.0f-3*F);

    if( variant==0 )

      {

      float[][] bands     = { {0.015f,35,0.25f*F,0.5f*F,5,1,1},{0.001f,35,0.25f*F,0.5f*F,5,1,1} };

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

      float[][] corners   = { {0.08f,0.20f*F},{0.07f,0.20f*F} };

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

      float[][] centers   = { { 0.0f, Y, Z-F/2} };

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

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

      }

    else if( variant==1 )

      {

      float[][] bands     = { {0.015f,35,0.5f*F,F,5,1,1},{0.001f,35,0.5f*F,F,5,1,1} };

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

      float[][] corners   = { {0.07f,0.20f*F} };

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

      float[][] centers   = { { 0, F*SQ2/2, 0 } };

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

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

      }

    else

      {

      float[][] bands     = { {0.020f,35,0.20f*L,0.6f*L,5,1,1}, {0.001f,35,0.05f*L,0.1f*L,5,1,1} };

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

      float[][] corners   = { {0.04f,0.6f*F} };

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

      float[][] centers   = { { 0, -2*Y/3, 4*Z/3 } };

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

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

      }

    }

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

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

    {

    if( mQuats==null ) initializeQuats();

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

    return mQuats[mRotQuat[cubit]];

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 3;

    }

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

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

    {

    return cubit<4 ? 0 : (cubit<10?1:2);

    }

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

  public int getCubitFaceColor(int cubit, int face, int[] numLayers)

    {

    if( mFaceMap==null )

      {

      mFaceMap = new int[][]

         {

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

           { 1,  2,  3, -1, -1, -1 },

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

           { 1,  3,  0, -1, -1, -1 },

           { 3,  2, -1, -1, -1, -1 },

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

           { 3,  0, -1, -1, -1, -1 },

           { 1,  2, -1, -1, -1, -1 },

           { 3,  1, -1, -1, -1, -1 },

           { 0,  1, -1, -1, -1, -1 },

           { 0, -1, -1, -1, -1, -1 },

           { 1, -1, -1, -1, -1, -1 },

           { 2, -1, -1, -1, -1, -1 },

           { 3, -1, -1, -1, -1, -1 },

         };

      }

    return mFaceMap[cubit][face];

    }

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

  public float getStickerRadius()

    {

    return 0.04f;

    }

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

  public float getStickerStroke()

    {

    return ObjectControl.isInIconMode() ? 0.08f : 0.04f;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[] getBasicAngle()

    {

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

    return mBasicAngle;

    }

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

  public ObjectType intGetObjectType(int[] numLayers)

    {

    return ObjectType.JING_2;

    }

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

  public String getObjectName()

    {

    return "Jing Pyraminx";

    }

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

  public String getInventor()

    {

    return "Tony Fisher";

    }

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

  public int getYearOfInvention()

    {

    return 1991;

    }

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

  public int getComplexity()

    {

    return 1;

    }

}