Magic Cube

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

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

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.objects.TwistyBandagedCuboid;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

public class BandagedObject

{

    private static final float DIST2D = 0.5f;

    private final DistortedScreen mScreen;

    private final float[] mPos;

    private BandagedCubit[] mCubits;

    private int mX, mY, mZ;

    private int mNumCubits;

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

   BandagedObject(DistortedScreen screen)

     {

     mScreen = screen;

     mPos = new float[3];

     }

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

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

       }

     }

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

   private 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 d0 = pos1[3*i  ] - pos2[3*j  ];

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

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

         if( d0*d0 + d1*d1 + d2*d2 == 1 ) return true;

         }

     return false;

     }

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

   private int computeNumCubits(int x, int y, int z)

     {

     return ( x<=1 || y<=1 || z<=1 ) ? x*y*z : x*y*z-(x-2)*(y-2)*(z-2);

     }

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

   float getSize()

     {

     return mX>mY ? Math.max(mX, mZ) : Math.max(mY, mZ);

     }

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

   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;

     }

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

   TwistyObject createObject(int mode, float size)

     {

     float[][] pos = getCubitPositions();

     InitData data = new InitData( new int[] {mX,mY,mZ},pos);

     return new TwistyBandagedCuboid( TwistyObject.MESH_NICE, mode, ShapeHexahedron.DEFAULT_ROT, new Static3D(0,0,0), size, data, null );

     }

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

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

         }

       }

     }

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

   void attachCubits(float scale)

     {

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

       {

       mCubits[i].scaleMove(scale);

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

       mScreen.attach(node);

       }

     }

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

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

         }

       }

     }

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

   boolean tryChangeObject(int x, int y, int z)

     {

     if( mX!=x || mY!=y || mZ!=z )

       {

       mX = x;

       mY = y;

       mZ = z;

       mNumCubits = computeNumCubits(mX,mY,mZ);

       return true;

       }

     return false;

     }

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

   int computeProjectionAngle()

     {

     float quot1 = mZ/ (float)mX;

     float quot2 = mZ/ (float)mY;

     float quot3 = mX/ (float)mZ;

     float quot4 = mX/ (float)mY;

     float quot5 = Math.max(quot1,quot2);

     float quot6 = Math.max(quot3,quot4);

     float quot7 = Math.max(quot5,quot6);

          if( quot7<=1.0f ) return 120;

     else if( quot7<=1.5f ) return 90;

     else if( quot7<=2.0f ) return 60;

     else                   return 30;

     }

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

   void scaleCubits(float scale)

     {

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

     }

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

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

        }

     }

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

   float[] getDist3D()

     {

     float max = getSize();

     float x = 0.5f*(mX/max);

     float y = 0.5f*(mY/max);

     float z = 0.5f*(mZ/max);

     return new float[] {x,x,y,y,z,z};

     }

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

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

     {

     mCubits = new BandagedCubit[mNumCubits];

     int c=0;

     float begX = 0.5f*(1-mX);

     float begY = 0.5f*(1-mY);

     float begZ = 0.5f*(1-mZ);

     for(int x=0; x<mX; x++)

       for(int y=0; y<mY; y++)

          for(int z=0; z<mZ; z++)

            if( x==0 || x==mX-1 || y==0 || y==mY-1 || z==0 || z==mZ-1 )

              {

              float[] pos = new float[] { begX+x,begY+y,begZ+z };

              mCubits[c] = new BandagedCubit(pos,mX,mY,mZ,quatT,quatA,scale,false);

              c++;

              }

    }

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

  Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

  void touchCubit(int index)

    {

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

    }

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

  void untouchCubit(int index)

    {

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

    }

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

  void stretchPoint(int face, float[] output)

    {

    float max = getSize();

    switch(face/2)

      {

      case 0: output[0] *= (max/mZ); output[1] *= (max/mY); break;

      case 1: output[0] *= (max/mX); output[1] *= (max/mZ); break;

      case 2: output[0] *= (max/mX); output[1] *= (max/mY); break;

      }

    }

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

  int whichCubitTouched(int face, float pointX, float pointY)

    {

    switch(face)

      {

      case 0: mPos[0] = (mX-1)/2.0f;

              mPos[1] = (int)( mY*pointY+mY/2.0f)-(mY-1)/2.0f;

              mPos[2] = (int)(-mZ*pointX-mZ/2.0f)+(mZ-1)/2.0f;

              break;

      case 1: mPos[0] =-(mX-1)/2.0f;

              mPos[1] = (int)( mY*pointY+mY/2.0f)-(mY-1)/2.0f;

              mPos[2] = (int)( mZ*pointX+mZ/2.0f)-(mZ-1)/2.0f;

              break;

      case 2: mPos[0] = (int)( mX*pointX+mX/2.0f)-(mX-1)/2.0f;

              mPos[1] = (mY-1)/2.0f;

              mPos[2] = (int)(-mZ*pointY-mZ/2.0f)+(mZ-1)/2.0f;

              break;

      case 3: mPos[0] = (int)( mX*pointX+mX/2.0f)-(mX-1)/2.0f;

              mPos[1] =-(mY-1)/2.0f;

              mPos[2] = (int)( mZ*pointY+mZ/2.0f)-(mZ-1)/2.0f;

              break;

      case 4: mPos[0] = (int)( mX*pointX+mX/2.0f)-(mX-1)/2.0f;

              mPos[1] = (int)( mY*pointY+mY/2.0f)-(mY-1)/2.0f;

              mPos[2] = (mZ-1)/2.0f;

              break;

      case 5: mPos[0] = (int)(-mX*pointX-mX/2.0f)+(mX-1)/2.0f;

              mPos[1] = (int)( mY*pointY+mY/2.0f)-(mY-1)/2.0f;

              mPos[2] =-(mZ-1)/2.0f;

              break;

      }

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

      if( mCubits[c].isAttached() )

        {

        float[] pos = mCubits[c].getPosition();

        int len = pos.length/3;

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

          if( pos[3*p]==mPos[0] && pos[3*p+1]==mPos[1] && pos[3*p+2]==mPos[2] ) return c;

        }

    android.util.Log.e("D", "whichCubitTouched: IMPOSSIBLE!!");

    return -1;

    }

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

  boolean isInsideFace(int face, float[] p)

    {

    return ( p[0]<=DIST2D && p[0]>=-DIST2D && p[1]<=DIST2D && p[1]>=-DIST2D );

    }

}