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.SQ3;

import org.distorted.library.helpers.QuatHelper;

import org.distorted.objectlib.bandaged.FactoryBandagedSkewb;

import java.util.ArrayList;

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

public class ObjectSignatureSkewb extends ObjectSignature

{

  private static final float[][] ROT_AXIS =

    {

      { SQ3/3, SQ3/3, SQ3/3 },

      { SQ3/3, SQ3/3,-SQ3/3 },

      { SQ3/3,-SQ3/3, SQ3/3 },

      { SQ3/3,-SQ3/3,-SQ3/3 },

    };

  private static final float[][] QUATS =

    {

      { 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 },

    };

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

// Bandaged Skewb objects when read from JSON

  public ObjectSignatureSkewb(int x, long[] signature)

    {

    super(signature);

    mTmp = new float[4];

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

    prepareCubitTouch();

    prepareTouchRows();

    prepareAllCycles();

    }

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

// Locally created bandaged Skewbs 2<=N<=3

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

            {

            float xc = (xi+xj)/2;

            float yc = (yi+yj)/2;

            float zc = (zi+zj)/2;

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

            setBit(bitIndex,1);

            }

          }

        }

      }

    }

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

  private void prepareCubitTouch()

    {

    FactoryBandagedSkewb factory = FactoryBandagedSkewb.getInstance();

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

    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 = first[0];

      float oy = first[1];

      float oz = first[2];

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

        {

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

        float tx = second[0];

        float ty = second[1];

        float tz = second[2];

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

          {

          float xc = (tx+ox)/2;

          float yc = (ty+oy)/2;

          float zc = (tz+oz)/2;

          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[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 = numLayers==2 ? (d/SQ3 + 1.01f) : (d/(0.75f*SQ3) + 1.51f);

    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 x1, float y1, float z1, float x2, float y2, float z2)

    {

    float dx = x1-x2;

    float dy = y1-y2;

    float dz = z1-z2;

    if( dx*dx + dy*dy + dz*dz < 2*1.01f )

      {

      float s = 0.25f*mLayer[0]*mLayer[0];

      return (x1==x2 && x1*x1==s) || (y1==y2 && y1*y1==s) || (z1==z2 && z1*z1==s);

      }

    return false;

    }

}