TwistyPuzzleLib

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

// Copyright 2022 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_CHANGING_MIRROR;

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

import org.distorted.library.effect.EffectName;

import org.distorted.library.helpers.QuatHelper;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.metadata.ListObjects;

import org.distorted.objectlib.metadata.Metadata;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

public class TwistyPenrose extends ShapeHexahedron

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

  private int[][] mEdges;

  private int[][] mBasicAngle;

  private float[][] mCuts;

  private int[] mQuatIndex;

  private int[][] mFaceMap;

  private int[][] mQuatDivided;

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

  public TwistyPenrose(int iconMode, Static4D quat, Static3D move, float scale, Metadata meta, InitAssets asset)

    {

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

    }

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

// { -0.5f, -0.49999997f, 0.5f, -0.49999997f, 0.5f, 0.49999997f, -0.5f, 0.49999997f}

// { -0.24999999f, 0.5f, -0.24999999f, -0.24999999f, 0.5f, -0.24999999f}

// { -0.5f, -0.08578644f, -0.08578644f, -0.49999997f, 0.5f, 0.08578644f, 0.085786454f, 0.5f}

  @Override

  public void adjustStickerCoords()

    {

    final float A = 0.50f;

    final float B = 0.25f;

    final float C = 0.08578644f;

    final float D = 0.23f;

    final float E = (A+D)/5;

    final float F = 0.005f;

    final float G = (A+D)/2;

    final float H = 0.002f;

    mStickerCoords = new float[][][][]

          {

            { { {-A,-A},{ A,-A},{ A, A},{-A, A} } },

            { { {-B, A},{-B,-B},{ A,-B},{ A,-D},{A-E+F,-D+E+F},{A-2*E,-D+2*E},{A-G+H,-D+G+H},{-D+2*E,A-2*E},{-D+E+F,A-E+F},{-D, A} } },

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

          };

    }

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

  @Override

  protected float[][][] getStickerRadii()

    {

    float R = getStickerRadius();

    float R2 = 1.3f*R;

    return new float[][][]

      {

        { { R, R, R, R } },

        { { R2, R, R2, 0, 0,0,0,0,0, 0 } },

        { { R, R, R, R } },

      };

    }

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

// remember about the double cover or unit quaternions!

  private int mulQuat(int q1, int q2)

    {

    Static4D result = QuatHelper.quatMultiply(mObjectQuats[q1],mObjectQuats[q2]);

    return findQuatIndex(result);

    }

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

// remember about the double cover or unit quaternions!

  private int findQuatIndex(Static4D quat)

    {

    int numQ = mObjectQuats.length;

    float rX = quat.get0();

    float rY = quat.get1();

    float rZ = quat.get2();

    float rW = quat.get3();

    final float MAX_ERROR = 0.1f;

    float dX,dY,dZ,dW;

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

      {

      dX = mObjectQuats[i].get0() - rX;

      dY = mObjectQuats[i].get1() - rY;

      dZ = mObjectQuats[i].get2() - rZ;

      dW = mObjectQuats[i].get3() - rW;

      if( dX<MAX_ERROR && dX>-MAX_ERROR &&

          dY<MAX_ERROR && dY>-MAX_ERROR &&

          dZ<MAX_ERROR && dZ>-MAX_ERROR &&

          dW<MAX_ERROR && dW>-MAX_ERROR  ) return i;

      dX = mObjectQuats[i].get0() + rX;

      dY = mObjectQuats[i].get1() + rY;

      dZ = mObjectQuats[i].get2() + rZ;

      dW = mObjectQuats[i].get3() + rW;

      if( dX<MAX_ERROR && dX>-MAX_ERROR &&

          dY<MAX_ERROR && dY>-MAX_ERROR &&

          dZ<MAX_ERROR && dZ>-MAX_ERROR &&

          dW<MAX_ERROR && dW>-MAX_ERROR  ) return i;

      }

    return -1;

    }

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

// QDivided[i][j] = ObjectQ[i]/ObjectQ[j] -> QDivided[i][j] * ObjectQ[j] = ObjectQ[i]

  private void createQuatDivided()

    {

    int numQ = mObjectQuats.length;

    mQuatDivided = new int[numQ][numQ];

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

      for(int j=0; j<numQ; j++) mQuatDivided[i][j] = -3;

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

      for(int j=0; j<numQ; j++)

        {

        int q = mulQuat(i,j);

        mQuatDivided[q][j] = i;

        }

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

      for(int j=0; j<numQ; j++)

        if( mQuatDivided[i][j] == -3 )

          android.util.Log.e("D", "quat divided: "+i+" "+j);

    }

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

  @Override

  public int[][] getSolvedQuats()

    {

    if( mQuatDivided==null ) createQuatDivided();

    int[][] ret =  new int[][]

      {

              { 1, 12, mQuatDivided[15][12], mQuatDivided[17][12] },  // triplet of full edges 12<-->15<-->17

              { 1, 15, mQuatDivided[12][15], mQuatDivided[17][15] },

              { 1, 17, mQuatDivided[12][17], mQuatDivided[15][17] },

              { 1, 13, mQuatDivided[16][13], mQuatDivided[19][13] },  // triplet of full edges 13<-->16<-->19

              { 1, 16, mQuatDivided[13][16], mQuatDivided[19][16] },

              { 1, 19, mQuatDivided[13][19], mQuatDivided[16][19] },

              { 1, 11, mQuatDivided[14][11], mQuatDivided[18][11] },  // triplet of full edges 11<-->14<-->18

              { 1, 14, mQuatDivided[11][14], mQuatDivided[18][14] },

              { 1, 18, mQuatDivided[11][18], mQuatDivided[14][18] },

              { 1, 20, 1, 2, 3 },  // +X center; in-face rotations.

              { 1, 21, 1, 2, 3 },  // -X center

              { 1, 22, 4, 5, 6 },  // +Y center

              { 1, 23, 4, 5, 6 },  // -Y center

              { 1, 24, 7, 8, 9 },  // +Z center

              { 1, 25, 7, 8, 9 }   // -Z center

      };

    StringBuilder sb = new StringBuilder();

    int l = ret.length;

    sb.append("SOLVED QUATS");

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

      {

      sb.append("\ngroup ");

      sb.append(i);

      sb.append(" : ");

      for( int s : ret[i] )

        {

        sb.append(' ');

        sb.append(s);

        }

      }

    android.util.Log.e("D", sb.toString() );

    return ret;

    }

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

// we need to manually change the colors of the faces

  @Override

  public int getCubitFaceMap(int cubit, int face)

    {

    if( mFaceMap==null )

      {

      final int C1 = 1;

      final int C2 = 2;

      final int C3 = 4;

      mFaceMap = new int[][]

         {

                 {-1,C2,-1,C1,-1,C3},

                 {-1,C1,-1,C2,-1,C3},

                 {-1,C1,C2,-1,-1,-1},

                 {-1,C3,C2,-1,-1,-1},

                 {-1,C2,C3,-1,-1,-1},

                 {-1,C2,C1,-1,-1,-1},

                 {-1,C3,C1,-1,-1,-1},

                 {-1,C1,C3,-1,-1,-1},

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

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

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

                 {-1,-1,-1,C2,-1,C1},

                 {-1,-1,-1,C3,-1,C2},

                 {-1,-1,-1,C1,-1,C3},

                 {-1,-1,-1,C2,-1,C1},

                 {-1,-1,-1,C3,-1,C2},

                 {-1,-1,-1,C3,-1,C1},

                 {-1,-1,-1,C3,-1,C2},

                 {-1,-1,-1,C2,-1,C1},

                 {-1,-1,-1,C3,-1,C1},

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

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

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

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

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

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

         };

      }

    return mFaceMap[cubit][face];

    }

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

  public int[][] getScrambleEdges()

    {

    int[] numL = getNumLayers();

    if( mEdges==null ) mEdges = ScrambleEdgeGenerator.getScrambleEdgesCuboid(numL[0],numL[1],numL[2]);

    return mEdges;

    }

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

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

    {

    if( mCuts==null )

      {

      mCuts = new float[3][];

      for(int axis=0; axis<3; axis++)

        {

        int len = numLayers[axis];

        float start = (2-len)*0.5f;

        if( len>=2 )

          {

          mCuts[axis] = new float[len-1];

          for(int i=0; i<len-1; i++) mCuts[axis][i] = start+i;

          }

        }

      }

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

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][] { {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}} };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    return TouchControlHexahedron.D3D;

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

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

    {

    final int X = numLayers[0];

    final int Y = numLayers[1];

    final int Z = numLayers[2];

    final float lenX = 0.5f*(X-1);

    final float lenY = 0.5f*(Y-1);

    final float lenZ = 0.5f*(Z-1);

    int curPos = 0;

    int numCubits = X*Y*Z - (X-2)*(Y-2)*(Z-2);

    float[][] pos = new float[numCubits][];

    pos[curPos++] = new float[] {-lenX,+lenY,-lenZ};   // 2 full corners

    pos[curPos++] = new float[] {+lenX,-lenY,+lenZ};

    pos[curPos++] = new float[] {-lenX,-lenY,-lenZ};   // 6 round corners

    pos[curPos++] = new float[] {-lenX,-lenY,+lenZ};

    pos[curPos++] = new float[] {-lenX,+lenY,+lenZ};

    pos[curPos++] = new float[] {+lenX,-lenY,-lenZ};

    pos[curPos++] = new float[] {+lenX,+lenY,-lenZ};

    pos[curPos++] = new float[] {+lenX,+lenY,+lenZ};

    for(int i=1; i<X-1; i++) pos[curPos++] = new float[] { i-lenX,  +lenY,  +lenZ };  // round edges

    for(int i=1; i<Y-1; i++) pos[curPos++] = new float[] {  +lenX, i-lenY,  -lenZ };

    for(int i=1; i<Z-1; i++) pos[curPos++] = new float[] {  -lenX,  -lenY, i-lenZ };

    for(int i=1; i<X-1; i++) pos[curPos++] = new float[] { i-lenX,  -lenY,  -lenZ };  // normal edges

    for(int i=1; i<X-1; i++) pos[curPos++] = new float[] { i-lenX,  -lenY,  +lenZ };

    for(int i=1; i<X-1; i++) pos[curPos++] = new float[] { i-lenX,  +lenY,  -lenZ };

    for(int i=1; i<Y-1; i++) pos[curPos++] = new float[] {  -lenX, i-lenY,  -lenZ };

    for(int i=1; i<Y-1; i++) pos[curPos++] = new float[] {  -lenX, i-lenY,  +lenZ };

    for(int i=1; i<Y-1; i++) pos[curPos++] = new float[] {  +lenX, i-lenY,  +lenZ };

    for(int i=1; i<Z-1; i++) pos[curPos++] = new float[] {  -lenX,  +lenY, i-lenZ };

    for(int i=1; i<Z-1; i++) pos[curPos++] = new float[] {  +lenX,  -lenY, i-lenZ };

    for(int i=1; i<Z-1; i++) pos[curPos++] = new float[] {  +lenX,  +lenY, i-lenZ };

    for(int y=1; y<Y-1; y++)

      for(int z=1; z<Z-1; z++) pos[curPos++] = new float[] {+lenX,y-lenY,z-lenZ};     // centers

    for(int y=1; y<Y-1; y++)

      for(int z=1; z<Z-1; z++) pos[curPos++] = new float[] {-lenX,y-lenY,z-lenZ};

    for(int x=1; x<X-1; x++)

      for(int z=1; z<Z-1; z++) pos[curPos++] = new float[] {x-lenX,+lenY,z-lenZ};

    for(int x=1; x<X-1; x++)

      for(int z=1; z<Z-1; z++) pos[curPos++] = new float[] {x-lenX,-lenY,z-lenZ};

    for(int x=1; x<X-1; x++)

      for(int y=1; y<Y-1; y++) pos[curPos++] = new float[] {x-lenX,y-lenY,+lenZ};

    for(int x=1; x<X-1; x++)

      for(int y=1; y<Y-1; y++) pos[curPos++] = new float[] {x-lenX,y-lenY,-lenZ};

    return pos;

    }

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

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

    {

    if( mQuatIndex==null )

      {

      mQuatIndex = new int[] { 3,5,

                               2,9,20,11,13,6,

                               6,11,2,

                               0,1,3,7,12,10,17,4,16,

                               6,4,1,3,0,2

                             };

      }

    return mObjectQuats[mQuatIndex[cubit]];

    }

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

  private float[][] getVertices(int variant)

    {

    if( variant==1 || variant==2 )

      {

      return new float[][]

          {

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

              {+0.5f,-0.5f,-0.5f },

              {+0.5f,+0.5f,-0.5f },

              {-0.5f,-0.5f,+0.5f },

              {+0.5f,-0.5f,+0.5f },

              {+0.5f,+0.5f,+0.5f },

          };

      }

    else

      {

      return new float[][]

          {

              { 0.5f, 0.5f, 0.5f },

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

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

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

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

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

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

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

          };

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( variant==1 || variant==2 )

      {

      int[][] indices =

          {

              {2,1,0},

              {3,4,5},

              {0,3,5,2},

              {0,1,4,3},

              {5,4,1,2}

          };

      return new ObjectShape(getVertices(variant), indices);

      }

    else

      {

      int[][] indices =

          {

              {2,3,1,0},

              {7,6,4,5},

              {4,0,1,5},

              {7,3,2,6},

              {6,2,0,4},

              {3,7,5,1}

          };

      return new ObjectShape(getVertices(variant), indices);

      }

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int extraI, extraV, n1, n2, numL = getNumLayers()[0];

    switch(numL)

        {

        case 2 : n1 = 6; n2 = 8; extraI = 2; extraV = 1; break;

        case 3 : n1 = 5; n2 = 7; extraI = 1; extraV = 1; break;

        case 4 : n1 = 5; n2 = 6; extraI = 1; extraV = 1; break;

        default: n1 = 5; n2 = 6; extraI = 0; extraV = 0; break;

        }

    float h1 = isInIconMode() ? 0.001f : 0.045f;

    float h2 = isInIconMode() ? 0.001f : 0.030f;

    int angle = 35;

    float R = 0.5f;

    float S = 0.7f;

    float[][] bands  =

         {

             {    h1,angle,R,S,n1,extraI,extraV},

             {0.001f,angle,R,S, 2,  n1-2,extraV},

             {0.001f,angle,R,S, 2,     0,     0},

             {0.001f,angle,R,S,n1,extraI,extraV},

             {    h2,angle,R,S,n2,extraI,extraV},

             {0.001f,angle,R,S,n2,extraI,extraV},

         };

    switch(variant)

      {

      case 0: return new ObjectFaceShape(bands,new int[] {3,0,3,0,3,0},null);

      case 1: return new ObjectFaceShape(bands,new int[] { 5,4,4,5,5 },null);

      case 2: return new ObjectFaceShape(bands,new int[] { 5,5,4,5,5 },null);

      case 3: return new ObjectFaceShape(bands,new int[] {1,1,1,0,1,0},null);

      case 4: return new ObjectFaceShape(bands,new int[] {2,2,2,2,0,2},null);

      }

    return null;

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    float[][] corners= { {0.030f,0.12f} };

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

    float[][] vertices= getVertices(variant);

    if( variant==1 || variant==2 )

      {

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

      ObjectVertexEffects effects = FactoryCubit.generateVertexEffect(vertices,corners,indices,centers,indices);

      String n = EffectName.PIPE.name();

      float[] v = {0.5f,0,0,1,0.92f};

      float[] c = {-0.5f,0.5f,0.0f};

      float[] r = {0,0,0,0};

      effects.joinEffect(n,v,c,r,true);

      return effects;

      }

    else

      {

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

      return FactoryCubit.generateVertexEffect(vertices,corners,indices,centers,indices);

      }

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    return 5;

    }

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

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

    {

    if( cubit<2  ) return 0;

    if( cubit<8  ) return 1;

    if( cubit<11 ) return 2;

    if( cubit<20 ) return 3;

    return 4;

    }

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

  public float getStickerRadius()

    {

    return 0.10f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.22f : 0.10f;

    }

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

  public float[][][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public String getShortName()

    {

    return ListObjects.PENR_3.name();

    }

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

  public int[][] getBasicAngles()

    {

    if( mBasicAngle ==null )

      {

      int num = getNumLayers()[0];

      int[] tmp = new int[num];

      for(int i=0; i<num; i++) tmp[i] = 4;

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

      }

    return mBasicAngle;

    }

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

  public String[][] getTutorials()

    {

    return new String[][]{

                          {"gb","Qit_PhYq-AI","Penrose Cube Tutorial","Manqube Manish Rathod"},

                          {"es","e6q1GwDeqFc","Tutorial del Penrose Cube","Rubiking"},

                          {"ru","LeYvajdcizQ","Как собрать Penrose Cube","YG Cuber"},

                          {"fr","jrHq_nZuQGk","Résolution du Penrose Cube","asthalis"},

                          {"de","P5dck40kTU0","Penrose Cube Tutorial","rofrisch"},

                          {"pl","o_c_pIOC6RU","Jak ułożyć kostkę Penrose","Kostki logiczne TV"},

                          {"br","6Iz95dtq1dE","Como resolver o Cubo Penrose","Cubo vício"},

                          {"kr","uzeoQzkDWM0","펜로즈 큐브","큐브놀이터"},

                          {"vn","PjyCCsxJyBU","Hướng dẫn giải Penrose Cube","Rubik Ocean"},

                          {"tw","lkzFMKmlB_8","Penrose Cube","不正常魔術方塊研究中心"},

                         };

    }

}