TwistyPuzzleLib

  public static boolean isAdjacent(int size, float dx, float dy, float dz)

    switch(size)

      case 2: float x2_0 = 2.01f;

      case 4: float x4_0 = 1.0f;

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

  float[][][] getPositions()

    {

    FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

    return factory.getPositions(mSize);

    }

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

  float getDist2D()

    {

    return (SIN54/COS54)/2;

    }

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

  int[] getColors()

    {

    return ShapeDodecahedron.FACE_COLORS;

    }

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

  boolean isAdjacent(float dx, float dy, float dz)

    {

    return isAdjacent(mSize[0],dx,dy,dz);

    }

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.objectlib.bandaged.BandagedObjectMegaminx;

import org.distorted.objectlib.bandaged.FactoryBandagedMegaminx;

import org.distorted.objectlib.touchcontrol.TouchControlDodecahedron;

  private static final float[][] mRotAxisMegaminx =

        {

                {    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[][] mQuatsMegaminx =

        {

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

        };

  private int mParam;

// Gigaminx has 480 such places (so more if N<=7)

    int ret = (int)(0.99f + (12*max*max)/64.0f);

    int giga= (int)(0.99f + (       480)/64.0f);

    return Math.max(ret,giga);

    mParam      = sig.mParam;

// or locally created bandaged pyraminxes, or locally bandaged megaminxes.

// How to tell apart: pyraminx's shortName starts with a 'P'; megaminx's shortName starts with a 'M'.

    char name = shortName.charAt(0);

    if( name == 'P' )

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

    else if( name == 'M' )

      {

      mTmp = new float[4];

      mParam=shortName.charAt(1)-'0';

      int x=-1;

      switch(mParam)

        {

        case 2:

        case 3: x = 3; break;

        case 4:

        case 5: x = 5; break;

        }

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

      prepareCubitTouchMegaminx();

      prepareTouchRowsMegaminx();

      prepareAllCyclesMegaminx();

      }

    else

      {

      int x=shortName.charAt(0)-'0';

      int y=shortName.charAt(1)-'0';

      int z=shortName.charAt(2)-'0';

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

      prepareCubitTouchCuboid();

      prepareTouchRowsCuboid();

      prepareAllCyclesCuboid();

      }

    prepareCubitTouchCuboid();

    prepareTouchRowsCuboid();

    prepareAllCyclesCuboid();

    prepareCubitTouchCuboid();

    prepareTouchRowsCuboid();

    prepareAllCyclesCuboid();

          if(areNeighboursCuboid(xi-xj,yi-yj,zi-zj))

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

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

  public ObjectSignature(float[][] position, int param)

    {

    int size = -1;

    switch(param)

      {

      case KILOMINX3: size = 2; break;

      case MEGAMINX3: size = 3; break;

      case KILOMINX5: size = 4; break;

      case MEGAMINX5: size = 5; break;

      }

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

    mSignature = new long[SIZE];

    mTmp = new float[4];

    prepareCubitTouchMegaminx();

    prepareTouchRowsMegaminx();

    prepareAllCyclesMegaminx();

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

            {

            float xc = (xi+xj)/2;  // TODO

            float yc = (yi+yj)/2;

            float zc = (zi+zj)/2;

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

            setBit(bitIndex,1);

            }

          }

        }

      }

    }

      {

      int[] touch = mTouchRows[axis];

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

        if( touch[index]==layer && getBit(index)!=0 )

          {

          android.util.Log.e("D", "axis "+axis+" layer "+layer+" is blocked from Left");

          return false;

          }

      }

             if( cycles[0].length==5 ) for(int[] cyc : cycles) ret.cycle5(turn,cyc);

        else if( cycles[0].length==4 ) for(int[] cyc : cycles) ret.cycle4(turn,cyc);

        else if( cycles[0].length==2 ) for(int[] cyc : cycles) ret.cycle2(cyc);

  private void cycle5(int turn, int[] cyc)

    {

    int index0 = cyc[0];

    int index1 = cyc[1];

    int index2 = cyc[2];

    int index3 = cyc[3];

    int index4 = cyc[4];

    long b0 = getBit(index0);

    long b1 = getBit(index1);

    long b2 = getBit(index2);

    long b3 = getBit(index3);

    long b4 = getBit(index4);

    switch(turn)

      {

      case 1: setBit(index0,b4);

              setBit(index1,b0);

              setBit(index2,b1);

              setBit(index3,b2);

              setBit(index4,b3);

              break;

      case 2: setBit(index0,b3);

              setBit(index1,b4);

              setBit(index2,b0);

              setBit(index3,b1);

              setBit(index4,b2);

              break;

      case 3: setBit(index0,b2);

              setBit(index1,b3);

              setBit(index2,b4);

              setBit(index3,b0);

              setBit(index4,b1);

              break;

      case 4: setBit(index0,b1);

              setBit(index1,b2);

              setBit(index2,b3);

              setBit(index3,b4);

              setBit(index4,b0);

              break;

    }

  }

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

  private void prepareCubitTouchCuboid()

        if( areNeighboursCuboid(x1-x2,y1-y2,z1-z2) )

  private void prepareTouchRowsCuboid()

    mTouchRows = new int[3][mNumCubitTouches];

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

  private void prepareAllCyclesCuboid()

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

    mTouchRows = new int[4][mNumCubitTouches];

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

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

  private float[] getPosition(int index, float[][][] centers, int len)

    {

    int num = 0, i1=0, i2=0;

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

      {

      int t = centers[i].length;

      if( t > index-num )

        {

        i1 = i;

        i2 = index-num;

        break;

        }

      else

        {

        num += t;

        }

      }

    return centers[i1][i2];

    }

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

  private void prepareCubitTouchMegaminx()

    {

    FactoryBandagedMegaminx factory = FactoryBandagedMegaminx.getInstance();

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

    int size = mLayer[0];

    int numCubits=0;

    int numVariants = centers.length;

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

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

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

      {

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

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

        {

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

        float ox = first[0];

        float oy = first[1];

        float oz = first[2];

        float tx = second[0];

        float ty = second[1];

        float tz = second[2];

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

          {

          float xc = (tx+ox)/2;  // TODO; wrong

          float yc = (ty+oy)/2;

          float zc = (tz+oz)/2;

          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 prepareTouchRowsMegaminx()

    {

    mTouchRows = new int[6][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<6; a++)

        {

        float[] ax = mRotAxisMegaminx[a];

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

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

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

        }

      }

    }

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

  private void prepareAllCyclesMegaminx()

    {

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

    generate5CyclesMegaminx(cycles0,0);

    generate5CyclesMegaminx(cycles1,1);

    generate5CyclesMegaminx(cycles2,2);

    generate5CyclesMegaminx(cycles3,3);

    generate5CyclesMegaminx(cycles4,4);

    generate5CyclesMegaminx(cycles5,5);

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

    int numLayers = mLayer[0];

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

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

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

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

    mCycles[4] = fillUpCyclesMegaminx(cycles4,4,numLayers);

    mCycles[5] = fillUpCyclesMegaminx(cycles5,5,numLayers);

    }

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

  private void generate5CyclesMegaminx(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);

      }

    }

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

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

    {

    int numCycles = cyc.size();

    int[] index = new int[numLayers];

    int[] numC = new int[numLayers];

    float[] ax = mRotAxisMegaminx[axis];

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

      {

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

      int layer = (int)whichLayerMegaminx(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)whichLayerMegaminx(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]);

      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 whichLayerMegaminx(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<0 ? 0:1;

      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, mQuatsMegaminx[ax]);

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

    }

  private boolean areNeighboursCuboid(float dx, float dy, float dz)

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

  private boolean areNeighboursMegaminx(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);

    }

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

        longName.equals(OBJECT_NAME_PYRAMINX) ||

        longName.equals(OBJECT_NAME_MEGAMINX)  ) return new ObjectSignature(shortName,signature);

  public static final int KILOMINX3 = 2; // don't change those values

  public static final int MEGAMINX3 = 3; // ( see ObjectSignature.areNeighboursMegaminx() )

  public static final int KILOMINX5 = 4; // ( and getShortName() here )

      mSignature = new ObjectSignature(mPosition,param);

// TYPE 2   (locally-created bandaged cuboids, pyraminxes & dodecahedrons)

    else if( mNumAxis==6 )

      {

      mTurns[0] = 4;

      mTurns[1] = 4;

      mTurns[2] = 4;

      mTurns[3] = 4;

      mTurns[4] = 4;

      mTurns[5] = 4;

      }