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

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

import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.C2;

import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.LEN;

import static org.distorted.objectlib.touchcontrol.TouchControlDodecahedron.SIN54;

import java.io.InputStream;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.touchcontrol.TouchControlDodecahedron;

import org.distorted.objectlib.scrambling.ScrambleState;

import org.distorted.objectlib.main.ShapeDodecahedron;

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

abstract class TwistyMinx extends ShapeDodecahedron

{

  static final int NUM_CORNERS = 20;

  static final int NUM_CENTERS = 12;

  static final int NUM_EDGES   = 30;

  static final float SIN18    = (SQ5-1)/4;

  static final float COS18    = (float)(0.25f*Math.sqrt(10.0f+2.0f*SQ5));

  static final float COS_HALFD= (float)(Math.sqrt(0.5f-0.1f*SQ5)); // cos(half the dihedral angle)

  static final float SIN_HALFD= (float)(Math.sqrt(0.5f+0.1f*SQ5)); // sin(half the dihedral angle)

  // the six rotation axis of a Minx. Must be normalized.

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(    C2/LEN, SIN54/LEN,    0      ),

           new Static3D(   -C2/LEN, SIN54/LEN,    0      ),

           new Static3D( 0        ,    C2/LEN, SIN54/LEN ),

           new Static3D( 0        ,   -C2/LEN, SIN54/LEN ),

           new Static3D( SIN54/LEN,    0     ,    C2/LEN ),

           new Static3D( SIN54/LEN,    0     ,   -C2/LEN )

         };

  private int[][] mBasicAngle;

  private float[][] mCuts;

  float[][] mCenterCoords,mCorners;

  int[] mQuatEdgeIndices,mQuatCornerIndices;

  int[][] mEdgeMap,mCenterMap;

  Static4D[] mBasicCornerV, mCurrCornerV;

  ScrambleState[] mStates;

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

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

    }

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

  public ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int[] numLayers = getNumLayers();

      initializeScrambleStates(numLayers[0]);

      }

    return mStates;

    }

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

  void initializeCornerV()

    {

    mBasicCornerV = new Static4D[3];

    mCurrCornerV  = new Static4D[3];

    mBasicCornerV[0] = new Static4D( (SQ5+1)*0.375f, (SQ5-1)*0.375f, -0.750f, 0.0f );

    mBasicCornerV[1] = new Static4D(-(SQ5+1)*0.375f, (SQ5-1)*0.375f, -0.750f, 0.0f );

    mBasicCornerV[2] = new Static4D(              0,        -1.500f,    0.0f, 0.0f );

    }

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

// the five vertices that form a given face. Order: the same as colors of the faces in TwistyMinx.

  void initializeCenterMap()

    {

    mCenterMap = new int[][]

         {

           { 0, 12,  8, 10, 16},

           { 0, 12,  4, 14,  2},

           { 0,  2, 18,  6, 16},

           { 6, 18, 11, 19,  7},

           { 3, 15,  9, 11, 19},

           { 4,  5, 15,  9, 14},

           { 1, 13,  5, 15,  3},

           { 1,  3, 19,  7, 17},

           {10, 16,  6,  7, 17},

           { 8, 13,  5,  4, 12},

           { 1, 13,  8, 10, 17},

           { 2, 14,  9, 11, 18},

         };

    }

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

// the quadruple ( corner1, corner2, face1, face2 ) defining an edge.

// In fact the 2 corners already define it, the faces only provide easy

// way to get to know the colors. Order: arbitrary. Face1 arbitrarily on

// the 'left' or right of vector corner1 --> corner2, according to Quat.

  void initializeEdgeMap()

    {

    mEdgeMap = new int[][]

         {

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

           {  0, 12,  1,  0},

           { 12,  4,  1,  9},

           {  4, 14,  1,  5},

           { 14,  2,  1, 11},

           { 14,  9, 11,  5}, //5

           {  9, 11, 11,  4},

           { 11, 18, 11,  3},

           { 18,  2, 11,  2},

           { 18,  6,  2,  3},

           {  6, 16,  2,  8}, //10

           { 16,  0,  2,  0},

           { 16, 10,  0,  8},

           { 10,  8,  0, 10},

           {  8, 12,  0,  9},

           {  8, 13,  9, 10}, //15

           { 13,  5,  9,  6},

           {  5,  4,  9,  5},

           {  5, 15,  5,  6},

           { 15,  9,  5,  4},

           { 11, 19,  3,  4}, //20

           { 19,  7,  3,  7},

           {  7,  6,  3,  8},

           {  7, 17,  8,  7},

           { 17, 10,  8, 10},

           { 17,  1, 10,  7}, //25

           {  1,  3,  6,  7},

           {  3, 19,  4,  7},

           {  1, 13, 10,  6},

           {  3, 15,  6,  4},

         };

    }

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

  void initializeQuatIndices()

    {

    mQuatEdgeIndices = new int[]

      {

         0, 17, 18, 19, 20, 56, 25,  5, 24, 16,

         9, 44,  1, 34, 35, 27, 41, 50, 26, 54,

        15, 49, 39, 28, 10,  2, 48,  6, 46,  3

      };

    mQuatCornerIndices = new int[]

      {

         0, 29, 59, 48, 18, 53, 22, 49, 11, 54,

        10, 52, 17, 27, 19, 26,  9, 28, 23, 45

      };

    }

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

// Coordinates of all 20 corners of a Minx

  void initializeCorners()

    {

    float cA = 1.5f;

    float cB = 3*C2;

    float cC = 3*SIN54;

    mCorners = new float[][]

         {

             {  0, cA, cB},

             {  0, cA,-cB},

             {  0,-cA, cB},

             {  0,-cA,-cB},

             { cB,  0, cA},

             { cB,  0,-cA},

             {-cB,  0, cA},

             {-cB,  0,-cA},

             { cA, cB,  0},

             { cA,-cB,  0},

             {-cA, cB,  0},

             {-cA,-cB,  0},

             { cC, cC, cC},

             { cC, cC,-cC},

             { cC,-cC, cC},

             { cC,-cC,-cC},

             {-cC, cC, cC},

             {-cC, cC,-cC},

             {-cC,-cC, cC},

             {-cC,-cC,-cC},

         };

    }

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

  void initializeCenterCoords()

    {

    if( mCorners==null ) initializeCorners();

    if( mCenterMap==null ) initializeCenterMap();

    mCenterCoords = new float[NUM_CENTERS][3];

    for(int center=0; center<NUM_CENTERS; center++)

      {

      int[] map = mCenterMap[center];

      float x = mCorners[map[0]][0] +

                mCorners[map[1]][0] +

                mCorners[map[2]][0] +

                mCorners[map[3]][0] +

                mCorners[map[4]][0] ;

      float y = mCorners[map[0]][1] +

                mCorners[map[1]][1] +

                mCorners[map[2]][1] +

                mCorners[map[3]][1] +

                mCorners[map[4]][1] ;

      float z = mCorners[map[0]][2] +

                mCorners[map[1]][2] +

                mCorners[map[2]][2] +

                mCorners[map[3]][2] +

                mCorners[map[4]][2] ;

      mCenterCoords[center][0] = x/5;

      mCenterCoords[center][1] = y/5;

      mCenterCoords[center][2] = z/5;

      }

    }

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

  private int[] generateL(int numLayers, int index)

    {

    int rows = (numLayers-1)/2;

    int[] ret = new int[3*4*rows];

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

      {

      ret[12*i   ] = i;

      ret[12*i+ 1] =-2;

      ret[12*i+ 2] = index;

      ret[12*i+ 3] = i;

      ret[12*i+ 4] =-1;

      ret[12*i+ 5] = index;

      ret[12*i+ 6] = i;

      ret[12*i+ 7] =+1;

      ret[12*i+ 8] = index;

      ret[12*i+ 9] = i;

      ret[12*i+10] =+2;

      ret[12*i+11] = index;

      }

    return ret;

    }

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

  private int[] generateR(int numLayers, int index)

    {

    int rows = (numLayers-1)/2;

    int[] ret = new int[3*4*rows];

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

      {

      int lay = rows+i+1;

      ret[12*i   ] = lay;

      ret[12*i+ 1] =-2;

      ret[12*i+ 2] = index;

      ret[12*i+ 3] = lay;

      ret[12*i+ 4] =-1;

      ret[12*i+ 5] = index;

      ret[12*i+ 6] = lay;

      ret[12*i+ 7] =+1;

      ret[12*i+ 8] = index;

      ret[12*i+ 9] = lay;

      ret[12*i+10] =+2;

      ret[12*i+11] = index;

      }

    return ret;

    }

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

  private int[] generateB(int numLayers, int index)

    {

    int rows = (numLayers-1);

    int half = rows/2;

    int[] ret = new int[3*4*rows];

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

      {

      int ind = i<half? index : index+1;

      int lay = i<half? i : i+1;

      ret[12*i   ] = lay;

      ret[12*i+ 1] =-2;

      ret[12*i+ 2] = ind;

      ret[12*i+ 3] = lay;

      ret[12*i+ 4] =-1;

      ret[12*i+ 5] = ind;

      ret[12*i+ 6] = lay;

      ret[12*i+ 7] =+1;

      ret[12*i+ 8] = ind;

      ret[12*i+ 9] = lay;

      ret[12*i+10] =+2;

      ret[12*i+11] = ind;

      }

    return ret;

    }

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

  private void initializeScrambleStates(int numLayers)

    {

    int[] LEFT0 = generateL(numLayers,1);

    int[] RIGH0 = generateR(numLayers,2);

    int[] LEFT1 = generateL(numLayers,3);

    int[] RIGH1 = generateR(numLayers,4);

    int[] LEFT2 = generateL(numLayers,5);

    int[] RIGH2 = generateR(numLayers,6);

    int[] LEFT3 = generateL(numLayers,7);

    int[] RIGH3 = generateR(numLayers,8);

    int[] LEFT4 = generateL(numLayers,9);

    int[] RIGH4 = generateR(numLayers,10);

    int[] LEFT5 = generateL(numLayers,11);

    int[] RIGH5 = generateR(numLayers,12);

    int[] BOTH1 = generateB(numLayers,1);

    int[] BOTH3 = generateB(numLayers,3);

    int[] BOTH5 = generateB(numLayers,5);

    int[] BOTH7 = generateB(numLayers,7);

    int[] BOTH9 = generateB(numLayers,9);

    int[] BOTH11= generateB(numLayers,11);

    mStates = new ScrambleState[]

      {

      new ScrambleState( new int[][] { BOTH1,BOTH3,BOTH5,BOTH7,BOTH9,BOTH11 } ), // beg

      new ScrambleState( new int[][] { {}   ,RIGH1,LEFT2,RIGH3,LEFT4,LEFT5  } ), // 0L

      new ScrambleState( new int[][] { {}   ,LEFT1,RIGH2,LEFT3,RIGH4,RIGH5  } ), // 0R

      new ScrambleState( new int[][] { RIGH0,{}   ,LEFT2,RIGH3,RIGH4,RIGH5  } ), // 1L

      new ScrambleState( new int[][] { LEFT0,{}   ,RIGH2,LEFT3,LEFT4,LEFT5  } ), // 1R

      new ScrambleState( new int[][] { LEFT0,LEFT1,{}   ,RIGH3,LEFT4,RIGH5  } ), // 2L

      new ScrambleState( new int[][] { RIGH0,RIGH1,{}   ,LEFT3,RIGH4,LEFT5  } ), // 2R

      new ScrambleState( new int[][] { RIGH0,RIGH1,RIGH2,{}   ,LEFT4,RIGH5  } ), // 3L

      new ScrambleState( new int[][] { LEFT0,LEFT1,LEFT2,{}   ,RIGH4,LEFT5  } ), // 3R

      new ScrambleState( new int[][] { LEFT0,RIGH1,LEFT2,LEFT3,{}   ,RIGH5  } ), // 4L

      new ScrambleState( new int[][] { RIGH0,LEFT1,RIGH2,RIGH3,{}   ,LEFT5  } ), // 4R

      new ScrambleState( new int[][] { LEFT0,RIGH1,RIGH2,RIGH3,RIGH4,{}     } ), // 5L

      new ScrambleState( new int[][] { RIGH0,LEFT1,LEFT2,LEFT3,LEFT4,{}     } ), // 5R

      };

    }

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

  float[][] genericGetCuts(int numLayers, float dist)

    {

    if( mCuts==null )

      {

      mCuts = new float[6][numLayers-1];

      float D = numLayers* TouchControlDodecahedron.DIST3D;

      float X = 2*D/(2+SIN18);  // height of the 'upper' part of a dodecahedron, i.e. put it on a table,

                                // its height is then 2D, it has one 'lower' part of height X, one

                                // 'middle' part of height Y and one upper part of height X again.

      int num = (numLayers-1)/2;

      float G = X*dist/num;     // height of one Layer

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

        {

        float cut = -D + (i+0.85f)*G;  // 0.85? not fully correct; attempt to make it

                                       // easier to rotate the outer layers

        int j = 2*num-1-i;

        mCuts[0][i] = +cut;

        mCuts[0][j] = -cut;

        mCuts[1][i] = +cut;

        mCuts[1][j] = -cut;

        mCuts[2][i] = +cut;

        mCuts[2][j] = -cut;

        mCuts[3][i] = +cut;

        mCuts[3][j] = -cut;

        mCuts[4][i] = +cut;

        mCuts[4][j] = -cut;

        mCuts[5][i] = +cut;

        mCuts[5][j] = -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;

      layerRotatable[i][numLayers[i]/2] = false;

      }

    return layerRotatable;

    }

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

  public int getTouchControlType()

    {

    return TC_DODECAHEDRON;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_SPLIT_EDGE;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][]

      {

          {{2,3},{3,5},{1,5},{1,4},{2,4}},

          {{0,5},{2,5},{2,3},{3,4},{0,4}},

          {{2,3},{2,5},{0,5},{0,4},{3,4}},

          {{1,5},{3,5},{2,3},{2,4},{1,4}},

          {{0,3},{0,4},{4,5},{1,5},{1,3}},

          {{1,2},{1,4},{4,5},{0,5},{0,2}},

          {{4,5},{1,4},{1,2},{0,2},{0,5}},

          {{4,5},{0,4},{0,3},{1,3},{1,5}},

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

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

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

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

      };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlDodecahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlDodecahedron.FACE_AXIS;

    }

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

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

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

      }

    return mBasicAngle;

    }

}