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 org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.touchcontrol.TouchControlDodecahedron;

import org.distorted.objectlib.shape.ShapeDodecahedron;

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

abstract class TwistyDodecahedron 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;

  int[][] mEdges;

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

  TwistyDodecahedron(int meshState, int iconMode, Static4D quat, Static3D move, float scale, InitData data, InitAssets asset)

    {

    super(meshState, iconMode, data.getNumLayers()[0], quat, move, scale, data, asset);

    }

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

  private void fillRet(int[] table, int index, int count, int startMove, int graphVertex)

    {

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

      {

      table[index+2*i  ] = startMove++;

      table[index+2*i+1] = graphVertex;

      }

    }

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

  private int[] genEdge(int numLayers, int x0, int x1, int x2, int x3, int x4, int x5,

                                       int x6, int x7, int x8, int x9, int x10,int x11)

    {

    int layers = (numLayers-1)/2;

    int num = 8*layers;

    int size = 0;

    int count   = 4*layers;

    int offset1 = 4*layers + (numLayers%2==1 ? 4:0);  // omit the middle layer, if it exists.

    int offset2 = 4*layers;

    if( x0 >=0 ) size += num;

    if( x1 >=0 ) size += num;

    if( x2 >=0 ) size += num;

    if( x3 >=0 ) size += num;

    if( x4 >=0 ) size += num;

    if( x5 >=0 ) size += num;

    if( x6 >=0 ) size += num;

    if( x7 >=0 ) size += num;

    if( x8 >=0 ) size += num;

    if( x9 >=0 ) size += num;

    if( x10>=0 ) size += num;

    if( x11>=0 ) size += num;

    int[] ret = new int[size];

    int index = 0;

    int startMove = 0;

    if( x0 >=0 ) { fillRet(ret,index,count,startMove ,x0 ); index+=num; }

    startMove += offset1;

    if( x1 >=0 ) { fillRet(ret,index,count,startMove ,x1 ); index+=num; }

    startMove += offset2;

    if( x2 >=0 ) { fillRet(ret,index,count,startMove ,x2 ); index+=num; }

    startMove += offset1;

    if( x3 >=0 ) { fillRet(ret,index,count,startMove ,x3 ); index+=num; }

    startMove += offset2;

    if( x4 >=0 ) { fillRet(ret,index,count,startMove ,x4 ); index+=num; }

    startMove += offset1;

    if( x5 >=0 ) { fillRet(ret,index,count,startMove ,x5 ); index+=num; }

    startMove += offset2;

    if( x6 >=0 ) { fillRet(ret,index,count,startMove ,x6 ); index+=num; }

    startMove += offset1;

    if( x7 >=0 ) { fillRet(ret,index,count,startMove ,x7 ); index+=num; }

    startMove += offset2;

    if( x8 >=0 ) { fillRet(ret,index,count,startMove ,x8 ); index+=num; }

    startMove += offset1;

    if( x9 >=0 ) { fillRet(ret,index,count,startMove ,x9 ); index+=num; }

    startMove += offset2;

    if( x10>=0 ) { fillRet(ret,index,count,startMove ,x10); index+=num; }

    startMove += offset1;

    if( x11>=0 ) { fillRet(ret,index,count,startMove ,x11);             }

    return ret;

    }

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

  public int[][] getScrambleEdges()

    {

    if( mEdges==null )

      {

      int nL = getNumLayers()[0];

      mEdges = new int[][]

        {

        genEdge(nL, 1, 2,  3, 4,  5, 6,  7, 8,  9,10, 11,12),  // 0

        genEdge(nL,-1,-1, -1, 4,  5,-1, -1, 8,  9,-1, 11,-1),  // 0L

        genEdge(nL,-1,-1,  3,-1, -1, 6,  7,-1, -1,10, -1,12),  // 0R

        genEdge(nL,-1, 2, -1,-1,  5,-1, -1, 8, -1,10, -1,12),  // 1L

        genEdge(nL, 1,-1, -1,-1, -1, 6,  7,-1,  9,-1, 11,-1),  // 1R

        genEdge(nL, 1,-1,  3,-1, -1,-1, -1, 8,  9,-1, -1,12),  // 2L

        genEdge(nL,-1, 2, -1, 4, -1,-1,  7,-1, -1,10, 11,-1),  // 2R

        genEdge(nL,-1, 2, -1, 4, -1, 6, -1,-1,  9,-1, -1,12),  // 3L

        genEdge(nL, 1,-1,  3,-1,  5,-1, -1,-1, -1,10, 11,-1),  // 3R

        genEdge(nL, 1,-1, -1, 4,  5,-1,  7,-1, -1,-1, -1,12),  // 4L

        genEdge(nL,-1, 2,  3,-1,  5,-1, -1, 8, -1,-1, 11,-1),  // 4R

        genEdge(nL, 1,-1, -1, 4, -1, 6, -1, 8, -1,10, -1,-1),  // 5L

        genEdge(nL,-1, 2,  3,-1,  5,-1,  7,-1,  9,-1, -1,-1),  // 5R

        };

      }

    return mEdges;

    }

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

  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;

      }

    }

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

  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;

    }

}