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

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.main.TwistyObject;

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

public abstract class BandagedObject

{

    private final DistortedScreen mScreen;

    private final float[][] mFaceAxis;

    private BandagedCubit[] mCubits;

    private final float[][] mRotAxis;

    float[][] mCuts;

    final int[] mSize;

    final float mDist2D;

    int mMax;

    int mNumCubits;

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

   BandagedObject(DistortedScreen screen)

     {

     mScreen = screen;

     mRotAxis = getRotAxis();

     mSize = new int[mRotAxis.length];

     mDist2D = getDist2D();

     Static3D[] axis = getFaceAxis();

     int numAxis = axis.length;

     mFaceAxis = new float[numAxis][];

     for(int i=0; i<numAxis; i++) mFaceAxis[i] = new float[] { axis[i].get0(), axis[i].get1(), axis[i].get2() };

     }

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

   abstract float[][] getRotAxis();

   abstract float getDist2D();

   abstract int[] getColors();

   abstract float[][][] getPositions();

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

   abstract MeshBase createMesh(float[] pos, boolean round);

   public abstract TwistyObject createObject(int mode, float scale );

   public abstract float[] getDist3D();

   public abstract int computeProjectionAngle();

   public abstract boolean tryChangeObject(int x, int y, int z);

   public abstract boolean isInsideFace(int face, float[] p);

   public abstract Static3D[] getFaceAxis();

   public abstract float getScreenRatio();

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

  private float getRotRow(int ax, float d)

    {

    float[] cuts = mCuts[ax];

    int numCuts = cuts.length;

    for(int c=0; c<numCuts; c++) if( d<=cuts[c] ) return c;

    return numCuts;

    }

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

  float[][] getRotRows(float[] pos)

    {

    int num = pos.length/3;

    int numAx = mRotAxis.length;

    float[][] ret = new float[num][numAx];

    for(int p=0; p<num; p++)

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

        {

        float[] ax = mRotAxis[a];

        float x = pos[3*p];

        float y = pos[3*p+1];

        float z = pos[3*p+2];

        float d = ax[0]*x + ax[1]*y + ax[2]*z;

        ret[p][a] = getRotRow(a,d);

        }

    return ret;

    }

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

   public void createCubits(Static4D quatT, Static4D quatA, Static3D scale)

     {

     mCubits = new BandagedCubit[mNumCubits];

     float[][][] pos = getPositions();

     int c=0;

     for(float[][] po : pos)

        for(float[] p : po)

          mCubits[c++] = new BandagedCubit(this, p, quatT, quatA, scale, false);

     }

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

   int computeMapsIndex(float[] faceAx)

      {

      int min=-1, numAxis = mFaceAxis.length;

      float error = Float.MAX_VALUE;

      float x = faceAx[0];

      float y = faceAx[1];

      float z = faceAx[2];

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

        {

        float[] ax = mFaceAxis[i];

        float dx = x-ax[0];

        float dy = y-ax[1];

        float dz = z-ax[2];

        float diff = dx*dx + dy*dy + dz*dz;

        if( error>diff )

          {

          error = diff;

          min = i;

          }

        }

      return min;

      }

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

   public void resetObject(float scale)

     {

     for(int c=0; c<mNumCubits; c++)

       {

       if( !mCubits[c].isAttached() )

         {

         mCubits[c].attach();

         mScreen.attach(mCubits[c].getNode());

         }

       if( mCubits[c].getPosition().length>3 )

         {

         mCubits[c].reset(scale);

         }

       mCubits[c].setUnmarked();

       }

     }

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

   public float getMaxSize()

     {

     return mMax;

     }

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

   float[][] getCubitPositions()

     {

     int numAttached = 0;

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

       if( mCubits[i].isAttached() ) numAttached++;

     float[][] pos = new float[numAttached][];

     int attached=0;

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

       if( mCubits[i].isAttached() )

         {

         pos[attached++] = mCubits[i].getPosition();

         }

     return pos;

     }

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

   public void tryConnectingCubits(int index1, int index2, float scale)

     {

     if( index1!=index2 )

       {

       float[] pos1 = mCubits[index1].getPosition();

       float[] pos2 = mCubits[index2].getPosition();

       if( isAdjacent(pos1,pos2) )

         {

         mCubits[index2].join(pos1,scale);

         mCubits[index1].detach();

         mScreen.detach(mCubits[index1].getNode());

         }

       }

     }

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

   public void attachCubits(float scale)

     {

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

       {

       mCubits[i].scaleMove(scale);

       DistortedNode node = mCubits[i].getNode();

       mScreen.attach(node);

       }

     }

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

   public void attachAndMarkCubits(float scale, int touched)

     {

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

       {

       if( mCubits[i].isAttached() )

         {

         mCubits[i].scaleMove(scale);

         if( touched==i ) mCubits[i].setMarked();

         else             mCubits[i].setUnmarked();

         DistortedNode node = mCubits[i].getNode();

         mScreen.attach(node);

         }

       }

     }

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

   public void scaleCubits(float scale)

     {

     for(int i=0; i<mNumCubits; i++) mCubits[i].scaleMove(scale);

     }

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

   public void recreateCubits(Static4D quatT, Static4D quatA, Static3D scale)

     {

     if( mCubits==null )

        {

        createCubits(quatT,quatA,scale);

        }

      else

        {

        for(int i=0; i<mNumCubits; i++) mCubits[i].recreateBitmap();

        }

     }

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

  public void touchCubit(int index)

    {

    if( index>=0 && index<mNumCubits && mCubits[index]!=null ) mCubits[index].setMarked();

    }

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

  public void untouchCubit(int index)

    {

    if( index>=0 && index<mNumCubits && mCubits[index]!=null ) mCubits[index].setUnmarked();

    }

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

  public int whichCubitTouched(float[] point3D)

    {

    float x = point3D[0]*mMax;

    float y = point3D[1]*mMax;

    float z = point3D[2]*mMax;

    int numAxis = mRotAxis.length;

    float[] rotRow = new float[numAxis];

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

      {

      float[] ax = mRotAxis[a];

      float d = ax[0]*x + ax[1]*y + ax[2]*z;

      rotRow[a] = getRotRow(a,d);

      }

    int diff = Integer.MAX_VALUE;

    int currBest = -1;

    for(int c=0; c<mNumCubits; c++)

      if( mCubits[c].isAttached() )

        {

        float[][] cubitRotRow = mCubits[c].getRotRow();

        for(float[] row : cubitRotRow)

          {

          int currDiff = 0;

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

            {

            float d = rotRow[a]-row[a];

            currDiff += d*d;

            }

          if( currDiff<diff )

            {

            diff = currDiff;

            currBest = c;

            }

          }

        }

    return currBest;

    }

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

  boolean isAdjacent(float[] pos1, float[] pos2)

     {

     int len1 = pos1.length/3;

     int len2 = pos2.length/3;

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

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

         {

         float dx = pos1[3*i  ] - pos2[3*j  ];

         float dy = pos1[3*i+1] - pos2[3*j+1];

         float dz = pos1[3*i+2] - pos2[3*j+2];

         if( isAdjacent(dx,dy,dz) ) return true;

         }

     return false;

     }

}