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.main.TwistyObject.SQ2;

import static org.distorted.objectlib.main.TwistyObject.SQ3;

import static org.distorted.objectlib.main.TwistyObject.SQ6;

import org.distorted.library.helpers.QuatHelper;

import org.distorted.objectlib.bandaged.FactoryBandagedOctahedron;

import java.util.ArrayList;

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

public class ObjectSignatureDiamond extends ObjectSignature

{

  private static final float[][] ROT_AXIS =

    {

      { SQ6/3,  SQ3/3,      0},

      {-SQ6/3,  SQ3/3,      0},

      {     0, -SQ3/3, -SQ6/3},

      {     0, -SQ3/3,  SQ6/3},

    };

  private static final float[][] QUATS =

    {

      { SQ2/2,  0.5f,      0, 0.5f },

      {-SQ2/2,  0.5f,      0, 0.5f },

      {     0, -0.5f, -SQ2/2, 0.5f },

      {     0, -0.5f,  SQ2/2, 0.5f },

    };

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

// Bandaged Diamond objects when read from JSON

  public ObjectSignatureDiamond(int x, long[] signature)

    {

    super(signature);

    mTmp = new float[4];

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

    prepareCubitTouch();

    prepareTouchRows();

    prepareAllCycles();

    }

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

// Locally created bandaged diamonds 2<=N<=5

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

    {

    mTmp = new float[4];

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

    mSignature = new long[SIZE];

    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(xi-xj,yi-yj,zi-zj) )

            {

            boolean octa = FactoryBandagedOctahedron.isOctahedron(yi);

            float xc,yc,zc;

            if( octa )

              {

              xc = (xi+2*xj)/3;

              yc = (yi+2*yj)/3;

              zc = (zi+2*zj)/3;

              }

            else

              {

              xc = (2*xi+xj)/3;

              yc = (2*yi+yj)/3;

              zc = (2*zi+zj)/3;

              }

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

            setBit(bitIndex,1);

            }

          }

        }

      }

    }

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

  private void prepareCubitTouch()

    {

    float[][][] centers = FactoryBandagedOctahedron.createPositions(mLayer[0]);

    float[][] octs = centers[0];

    float[][] tets = centers[1];

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

    for(float[] oct : octs)

      for(float[] tet : tets)

        {

        float ox=oct[0];

        float oy=oct[1];

        float oz=oct[2];

        float tx=tet[0];

        float ty=tet[1];

        float tz=tet[2];

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

          {

          float xc=(2*tx+ox)/3;

          float yc=(2*ty+oy)/3;

          float zc=(2*tz+oz)/3;

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

          mTouch.add(touch);

          }

        }

    mNumCubitTouches = mTouch.size();

    mCubitTouch = new float[mNumCubitTouches][];

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

    }

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

  private void prepareTouchRows()

    {

    mTouchRows = new int[4][mNumCubitTouches];

    int num = mLayer[0];

    final int N = 10;

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

      {

      float[] touch = mCubitTouch[i];

      for(int a=0; a<4; 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<>();

    generate3Cycles(cycles0,0);

    generate3Cycles(cycles1,1);

    generate3Cycles(cycles2,2);

    generate3Cycles(cycles3,3);

    mCycles = new int[4][][][];

    int numLayers = mLayer[0];

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

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

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

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

    }

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

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

    {

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

      {

      int i0 = rotateIndex3(ax,i);

      if( i0<=i ) continue;

      int i1 = rotateIndex3(ax,i0);

      if( i1<=i ) continue;

      float[] f0 = getCubitTouchOfIndex(i);

      float[] f1 = getCubitTouchOfIndex(i0);

      float[] f2 = getCubitTouchOfIndex(i1);

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

      cycles.add(cycle);

      }

    }

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

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

    {

    int numCycles = cyc.size();

    int[] index = new int[numLayers];

    int[] numC = new int[numLayers];

    float[] ax = ROT_AXIS[axis];

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

      {

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

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

      numC[layer]++;

      }

    int[][][] ret = new int[numLayers][][];

    for(int i=0; i<numLayers; 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,numLayers);

      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]);

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

      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 r = (SQ6/2)*d + numLayers*0.5f + 0.001f;

    return r>=numLayers ? numLayers-0.001f : r;

    }

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

  private int rotateIndex3(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(float dx, float dy, float dz)

    {

    return dx*dx+dy*dy+dz*dz < SQ6/4 + 0.01f;

    }

}