TwistyPuzzleLib

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

// Copyright 2023 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.signature;

import static org.distorted.objectlib.bandaged.BandagedObjectMegaminx.MEGA_D;

import static org.distorted.objectlib.bandaged.BandagedObjectMegaminx.SIN18;

import static org.distorted.objectlib.objects.TwistyBandagedMegaminx.KILOMINX3;

import static org.distorted.objectlib.objects.TwistyBandagedMegaminx.KILOMINX5;

import static org.distorted.objectlib.objects.TwistyBandagedMegaminx.MEGAMINX3;

import static org.distorted.objectlib.objects.TwistyBandagedMegaminx.MEGAMINX5;

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

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

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

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

import org.distorted.library.helpers.QuatHelper;

import org.distorted.objectlib.bandaged.BandagedObjectMegaminx;

import org.distorted.objectlib.bandaged.FactoryBandagedMegaminx;

import org.distorted.objectlib.touchcontrol.TouchControlDodecahedron;

import java.util.ArrayList;

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

public class ObjectSignatureMegaminx extends ObjectSignature

{

  private static final float[][] ROT_AXIS =

        {

                {    C2/LEN, SIN54/LEN,    0      },

                {   -C2/LEN, SIN54/LEN,    0      },

                { 0        ,    C2/LEN, SIN54/LEN },

                { 0        ,   -C2/LEN, SIN54/LEN },

                { SIN54/LEN,    0     ,    C2/LEN },

                { SIN54/LEN,    0     ,   -C2/LEN }

        };

  private static final float[][] QUATS =

        {

                {  COS54*   C2/LEN, COS54*SIN54/LEN, 0              , SIN54 },

                { -COS54*   C2/LEN, COS54*SIN54/LEN, 0              , SIN54 },

                {  0              , COS54*   C2/LEN, COS54*SIN54/LEN, SIN54 },

                {  0              ,-COS54*   C2/LEN, COS54*SIN54/LEN, SIN54 },

                {  COS54*SIN54/LEN, 0              , COS54*   C2/LEN, SIN54 },

                {  COS54*SIN54/LEN, 0              ,-COS54*   C2/LEN, SIN54 }

        };

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

// Bandaged Megaminx objects when read from JSON

  public ObjectSignatureMegaminx(int x, long[] signature)

    {

    super(signature);

    mTmp = new float[4];

    mParam=x;

    int z=-1, y=-1;

    switch(mParam)

      {

      case 2: z=3; y=2; break;

      case 3: z=3; y=3; break;

      case 4: z=5; y=4; break;

      case 5: z=5; y=5; break;

      }

    mLayer=new int[] {z,z,z,z,z,z};

    mFactoryLayer=new int[] {y,y,y,y,y,y};

    prepareCubitTouch();

    prepareTouchRows();

    prepareAllCycles();

    }

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

// Locally created bandaged megaminxes size 2<=N<=5

  public ObjectSignatureMegaminx(int x, float[][] position)

    {

    int y=-1;

    switch(x)

      {

      case KILOMINX3: y=3; mParam=2; break;

      case MEGAMINX3: y=3; mParam=3; break;

      case KILOMINX5: y=5; mParam=4; break;

      case MEGAMINX5: y=5; mParam=5; break;

      }

    mLayer=new int[] {y,y,y,y,y,y};

    mFactoryLayer=new int[] {mParam,mParam,mParam,mParam,mParam,mParam};

    mSignature = new long[SIZE];

    mTmp = new float[4];

    prepareCubitTouch();

    for(float[] pos : position)

      {

      int numCenters = pos.length/3;

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

        {

        float xi = pos[3*i  ];

        float yi = pos[3*i+1];

        float zi = pos[3*i+2];

        for(int j=i+1; j<numCenters; j++)

          {

          float xj = pos[3*j  ];

          float yj = pos[3*j+1];

          float zj = pos[3*j+2];

          if( areNeighbours(x,xi-xj,yi-yj,zi-zj) )

            {

            float xc = (xi+xj)/2;  // TODO; wrong; consequence of this is: mTouchRows

            float yc = (yi+yj)/2;  // in case of Megaminx and larger - not Kilominx -

            float zc = (zi+zj)/2;  // are wrong, and scrambling is not so perfect.

            int bitIndex = getIndexOfCubitTouch(xc,yc,zc);

            setBit(bitIndex,1);

            }

          }

        }

      }

    }

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

  private void prepareCubitTouch()

    {

    FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

    float[][][] centers = factory.getPositions(mFactoryLayer);

    int size = mFactoryLayer[0];

    float scale = 0.0f;

    switch(size)

      {

      case 2: scale = 1.50f; break;

      case 3: scale = 1.00f; break;

      case 4: scale = 1.25f; break;

      case 5: scale = 1.00f; break;

      }

    int numCubits=0;

    int numVariants = centers.length;

    for(float[][] center : centers) numCubits += center.length;

    ArrayList<float[]> touch = new ArrayList<>();

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

      {

      float[] first = getPosition(i,centers,numVariants);

      float ox = scale*first[0];

      float oy = scale*first[1];

      float oz = scale*first[2];

      for(int j=i+1; j<numCubits; j++)

        {

        float[] second = getPosition(j,centers,numVariants);

        float tx = scale*second[0];

        float ty = scale*second[1];

        float tz = scale*second[2];

        if( areNeighbours(size, ox-tx, oy-ty, oz-tz) )

          {

          float xc = (tx+ox)/2;  // TODO; wrong; consequence of this is: mTouchRows

          float yc = (ty+oy)/2;  // in case of Megaminx and larger - not Kilominx -

          float zc = (tz+oz)/2;  // are wrong, and scrambling is not so perfect.

          float[] t = new float[] {xc, yc, zc};

          touch.add(t);

          }

        }

      }

    mNumCubitTouches = touch.size();

    mCubitTouch = new float[mNumCubitTouches][];

    for(int i=0; i<mNumCubitTouches; i++) mCubitTouch[i] = touch.remove(0);

    }

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

  private void prepareTouchRows()

    {

    mTouchRows = new int[6][mNumCubitTouches];

    int num = mFactoryLayer[0];

    final int N = 10;

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

      {

      float[] touch = mCubitTouch[i];

      for(int a=0; a<6; a++)

        {

        float[] ax = ROT_AXIS[a];

        float l = whichLayer(touch,ax,num);

        int ll = (int)(N*l);

        mTouchRows[a][i] = ( (ll%N)==0 ) ? ll/N : -1;

        }

      }

    }

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

  private void prepareAllCycles()

    {

    ArrayList<float[][]> cycles0 = new ArrayList<>();

    ArrayList<float[][]> cycles1 = new ArrayList<>();

    ArrayList<float[][]> cycles2 = new ArrayList<>();

    ArrayList<float[][]> cycles3 = new ArrayList<>();

    ArrayList<float[][]> cycles4 = new ArrayList<>();

    ArrayList<float[][]> cycles5 = new ArrayList<>();

    generate5Cycles(cycles0,0);

    generate5Cycles(cycles1,1);

    generate5Cycles(cycles2,2);

    generate5Cycles(cycles3,3);

    generate5Cycles(cycles4,4);

    generate5Cycles(cycles5,5);

    mCycles = new int[6][][][];

    int param = mFactoryLayer[0];

    int numLayers = mLayer[0];

    mCycles[0] = fillUpCycles(cycles0,0,numLayers,param);

    mCycles[1] = fillUpCycles(cycles1,1,numLayers,param);

    mCycles[2] = fillUpCycles(cycles2,2,numLayers,param);

    mCycles[3] = fillUpCycles(cycles3,3,numLayers,param);

    mCycles[4] = fillUpCycles(cycles4,4,numLayers,param);

    mCycles[5] = fillUpCycles(cycles5,5,numLayers,param);

    }

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

  private void generate5Cycles(ArrayList<float[][]> cycles, int ax)

    {

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

      {

      int i0 = rotateIndex5(ax,i);

      if( i0<=i ) continue;

      int i1 = rotateIndex5(ax,i0);

      if( i1<=i ) continue;

      int i2 = rotateIndex5(ax,i1);

      if( i2<=i ) continue;

      int i3 = rotateIndex5(ax,i2);

      if( i3<=i ) continue;

      float[] f0 = getCubitTouchOfIndex(i);

      float[] f1 = getCubitTouchOfIndex(i0);

      float[] f2 = getCubitTouchOfIndex(i1);

      float[] f3 = getCubitTouchOfIndex(i2);

      float[] f4 = getCubitTouchOfIndex(i3);

      float[][] cycle = new float[][] { f0,f1,f2,f3,f4 };

      cycles.add(cycle);

      }

    }

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

// param 2 3 4 5

// numL  3 3 5 5

  private int[][][] fillUpCycles(ArrayList<float[][]> cyc, int axis, int numL, int param)

    {

    int numCycles = cyc.size();

    int[] index = new int[numL];

    int[] numC = new int[numL];

    float[] ax = ROT_AXIS[axis];

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

      {

      float[][] cycle = cyc.get(i);

      int layer = (int)whichLayer(cycle[0],ax,param);

      numC[layer]++;

      }

    int[][][] ret = new int[numL][][];

    for(int i=0; i<numL; i++) ret[i] = new int[numC[i]][];

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

      {

      float[][] cycle = cyc.remove(0);

      int layer = (int)whichLayer(cycle[0],ax,param);

      int i0 = getIndexOfCubitTouch(cycle[0][0],cycle[0][1],cycle[0][2]);

      int i1 = getIndexOfCubitTouch(cycle[1][0],cycle[1][1],cycle[1][2]);

      int i2 = getIndexOfCubitTouch(cycle[2][0],cycle[2][1],cycle[2][2]);

      int i3 = getIndexOfCubitTouch(cycle[3][0],cycle[3][1],cycle[3][2]);

      int i4 = getIndexOfCubitTouch(cycle[4][0],cycle[4][1],cycle[4][2]);

      ret[layer][index[layer]] = new int[] {i0,i1,i2,i3,i4};

      index[layer]++;

      }

    return ret;

    }

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

  private float whichLayer(float[] point, float[] ax, int numLayers)

    {

    float d = point[0]*ax[0] + point[1]*ax[1] + point[2]*ax[2];

    float C = 0.85f;

    switch(numLayers)

      {

      case 2: return (d*LEN)/(6*C2*SIN54) + 1.5f;

      case 3: float D3 = 3*TouchControlDodecahedron.DIST3D;

              float X3 = 2*D3/(2+SIN18);

              float G3 = X3*(0.5f-MEGA_D);

              float cut3 = -D3 + C*G3;

              return d<-cut3 ? 0 : d<cut3 ? 1:2;

      case 4: float D4 = 5*TouchControlDodecahedron.DIST3D;

              float X4 = 2*D4/(2+SIN18);

              float G4 = X4*0.25f;

              float cut41 = -D4 + C*G4;

              float cut42 = -D4 + (1+C)*G4;

              return d<-cut41 ? 0 : d<-cut42 ? 1: d<cut42 ? 2: d<cut41 ? 3:4;

      case 5: float D5 = 5*TouchControlDodecahedron.DIST3D;

              float X5 = 2*D5/(2+SIN18);

              float G5 = X5*(0.5f-MEGA_D)/2;

              float cut51 = -D5 + C*G5;

              float cut52 = -D5 + (1+C)*G5;

              return d<-cut51 ? 0 : d<-cut52 ? 1: d<cut52 ? 2: d<cut51 ? 3:4;

      }

    return 0;

    }

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

  private int rotateIndex5(int ax, int index)

    {

    float[] touch = getCubitTouchOfIndex(index);

    QuatHelper.rotateVectorByQuat(mTmp, touch[0], touch[1], touch[2], 1.0f, QUATS[ax]);

    return getIndexOfCubitTouch(mTmp[0],mTmp[1],mTmp[2]);

    }

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

  private boolean areNeighbours(int size, float dx, float dy, float dz)

    {

    float fact = size==2 ? 1.5f : (size==4 ? 1.25f : 1.0f);

    dx /= fact;

    dy /= fact;

    dz /= fact;

    return BandagedObjectMegaminx.isAdjacent(size,dx,dy,dz);

    }

}