Magic Cube

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

import android.graphics.Paint;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.type.Static4D;

import static org.distorted.effects.scramble.ScrambleEffect.START_AXIS;

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

  static final Static3D[] FACE_AXIS = new Static3D[]

         {

           new Static3D(0,1,0), new Static3D(0,-1,0),

           new Static3D(0,0,1), new Static3D(0,0,-1)

           0xff0000ff, 0xff00ff00,   // FACE_AXIS[2] (top  -BLUE  ) FACE_AXIS[3] (bottom-GREEN)

           0xffff0000, 0xffb5651d    // FACE_AXIS[4] (front-RED   ) FACE_AXIS[5] (back  -BROWN)

  // 1) compute how many rotations there are (RubikCube of any size = 24)

  // 2) take the AXIS, angles of rotation (90 in RubikCube's case) compute the basic quaternions

  // (i.e. rotations of 1 basic angle along each of the axis) and from there start semi-randomly

  // multiplying them and eventually you'll find all (24) legal rotations.

         new Static4D(  1.0f,   0.0f,   0.0f,   0.0f),

         new Static4D(  0.0f,   1.0f,   0.0f,   0.0f),

         new Static4D(  0.0f,   0.0f,   1.0f,   0.0f),

         new Static4D( SQ2/2,  SQ2/2,  0.0f ,   0.0f),

         new Static4D( SQ2/2, -SQ2/2,  0.0f ,   0.0f),

         new Static4D( SQ2/2,   0.0f,  SQ2/2,   0.0f),

         new Static4D(-SQ2/2,   0.0f,  SQ2/2,   0.0f),

         new Static4D( SQ2/2,   0.0f,   0.0f,  SQ2/2),

         new Static4D( SQ2/2,   0.0f,   0.0f, -SQ2/2),

         new Static4D(  0.0f,  SQ2/2,  SQ2/2,   0.0f),

         new Static4D(  0.0f,  SQ2/2, -SQ2/2,   0.0f),

         new Static4D(  0.0f,  SQ2/2,   0.0f,  SQ2/2),

         new Static4D(  0.0f,  SQ2/2,   0.0f, -SQ2/2),

         new Static4D(  0.0f,   0.0f,  SQ2/2,  SQ2/2),

         new Static4D(  0.0f,   0.0f,  SQ2/2, -SQ2/2),

         new Static4D(  0.5f,   0.5f,   0.5f,   0.5f),

         new Static4D(  0.5f,   0.5f,  -0.5f,   0.5f),

         new Static4D(  0.5f,   0.5f,  -0.5f,  -0.5f),

         new Static4D(  0.5f,  -0.5f,   0.5f,  -0.5f),

         new Static4D( -0.5f,  -0.5f,  -0.5f,   0.5f),

         new Static4D( -0.5f,   0.5f,  -0.5f,  -0.5f),

         new Static4D( -0.5f,   0.5f,   0.5f,  -0.5f),

         new Static4D( -0.5f,   0.5f,   0.5f,   0.5f)

  void createFaceTexture(Canvas canvas, Paint paint, int face, int left, int top, int side)

    {

    final float R = side*0.10f;

    final float M = side*0.05f;

    paint.setColor(FACE_COLORS[face]);

    canvas.drawRoundRect( left+M, top+M, left+side-M, top+side-M, R, R, paint);

    }

    Static3D[] tmp = new Static3D[numCubits];

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

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

          if( x==0 || x==size-1 || y==0 || y==size-1 || z==0 || z==size-1 )

    }

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

  int getNumStickerTypes()

    {

    return 1;

    }

  int getNumCubitFaces()

    {

    return FACE_COLORS.length;

  float getScreenRatio()

    {

    return 0.5f;

    }

  int getFaceColor(int cubit, int cubitface, int size)

    {

    boolean belongs = isOnFace(cubit, cubitface/2, cubitface%2==0 ? size-1:0 );

    return belongs ? cubitface : NUM_FACES;

    }

    int ordinal= RubikObjectList.CUBE.ordinal();

    int index  = RubikObjectList.getSizeIndex(ordinal,size);

    float D = 0.027f;

    float E = 0.5f-D;

    float[] vertices = { -E,-E, +E,-E, +E,+E, -E,+E };

    int extraI, extraV;

    switch(size)

      {

                                     1.0f-D  ,-D*0.25f,

                                     0.50f, 0.040f,

                                     0.0f, 0.048f };

               extraI = 2;

               extraV = 2;

                                     1.0f-D*1.2f,-D*0.55f,

                                     1.0f-2*D, 0.0f,

                                     0.50f, 0.040f,

                                     0.0f, 0.048f };

               extraI = 2;

               extraV = 2;

               break;

      case 4 : bands = new float[] { 1.0f    ,-D,

                                     1.0f-D*1.2f,-D*0.55f,

                                     1.0f-2*D, 0.0f,

                                     0.50f, 0.040f,

                                     0.0f, 0.048f };

               extraI = 1;

               extraV = 2;

               break;

      default: bands = new float[] { 1.0f    ,-D,

                                     1.0f-2*D, 0.0f,

                                     0.50f, 0.025f,

                                     0.0f, 0.030f };

               extraI = 1;

               extraV = 1;

      }

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

      {

      mMeshes = new MeshBase[RubikObjectList.CUBE.getNumVariants()];

      }

      final int MESHES=6;

      int association = 1;

      meshes[0] = new MeshPolygon(vertices,bands,extraI,extraV);

      for(int i=1; i<MESHES; i++)

        {

        association <<=1;

        meshes[i] = meshes[0].copy(true);

      Static3D axisY   = new Static3D(0,1,0);

      Static3D axisX   = new Static3D(1,0,0);

      Static3D center  = new Static3D(0,0,0);

      Static1D angle90 = new Static1D(90);

      Static1D angle180= new Static1D(180);

      Static1D angle270= new Static1D(270);

      float d2 =-0.05f;

      float d3 = 0.12f;

      Static3D dCen0 = new Static3D( d1*(+0.5f), d1*(+0.5f), d1*(+0.5f) );

      Static3D dCen1 = new Static3D( d1*(+0.5f), d1*(+0.5f), d1*(-0.5f) );

      Static3D dCen2 = new Static3D( d1*(+0.5f), d1*(-0.5f), d1*(+0.5f) );

      Static3D dCen3 = new Static3D( d1*(+0.5f), d1*(-0.5f), d1*(-0.5f) );

      Static3D dCen4 = new Static3D( d1*(-0.5f), d1*(+0.5f), d1*(+0.5f) );

      Static3D dCen5 = new Static3D( d1*(-0.5f), d1*(+0.5f), d1*(-0.5f) );

      Static3D dCen6 = new Static3D( d1*(-0.5f), d1*(-0.5f), d1*(+0.5f) );

      Static3D dCen7 = new Static3D( d1*(-0.5f), d1*(-0.5f), d1*(-0.5f) );

      Static3D dVec0 = new Static3D( d2*(+0.5f), d2*(+0.5f), d2*(+0.5f) );

      Static3D dVec1 = new Static3D( d2*(+0.5f), d2*(+0.5f), d2*(-0.5f) );

      Static3D dVec2 = new Static3D( d2*(+0.5f), d2*(-0.5f), d2*(+0.5f) );

      Static3D dVec3 = new Static3D( d2*(+0.5f), d2*(-0.5f), d2*(-0.5f) );

      Static3D dVec4 = new Static3D( d2*(-0.5f), d2*(+0.5f), d2*(+0.5f) );

      Static3D dVec5 = new Static3D( d2*(-0.5f), d2*(+0.5f), d2*(-0.5f) );

      Static3D dVec6 = new Static3D( d2*(-0.5f), d2*(-0.5f), d2*(+0.5f) );

      Static3D dVec7 = new Static3D( d2*(-0.5f), d2*(-0.5f), d2*(-0.5f) );

      Static4D dReg  = new Static4D(0,0,0,d3);

      Static1D dRad  = new Static1D(1);

      VertexEffectDeform effect7 = new VertexEffectDeform(dVec1, dRad, dCen1, dReg);

      VertexEffectDeform effect8 = new VertexEffectDeform(dVec2, dRad, dCen2, dReg);

      VertexEffectDeform effect9 = new VertexEffectDeform(dVec3, dRad, dCen3, dReg);

      VertexEffectDeform effect10= new VertexEffectDeform(dVec4, dRad, dCen4, dReg);

      VertexEffectDeform effect11= new VertexEffectDeform(dVec5, dRad, dCen5, dReg);

      VertexEffectDeform effect12= new VertexEffectDeform(dVec6, dRad, dCen6, dReg);

      VertexEffectDeform effect13= new VertexEffectDeform(dVec7, dRad, dCen7, dReg);

      mMeshes[index].apply(effect1);

      mMeshes[index].apply(effect2);

      mMeshes[index].apply(effect3);

      mMeshes[index].apply(effect4);

      mMeshes[index].apply(effect5);

      mMeshes[index].apply(effect6);

      mMeshes[index].apply(effect7);

      mMeshes[index].apply(effect8);

      mMeshes[index].apply(effect9);

      mMeshes[index].apply(effect10);

      mMeshes[index].apply(effect11);

      mMeshes[index].apply(effect12);

      mMeshes[index].apply(effect13);

      mMeshes[index].mergeEffComponents();

  float returnMultiplier()

    {

    return getSize();

    }

  float[] getRowChances()

    {

    int size = getSize();

    float[] chances = new float[size];

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

      {

      chances[i] = (i+1.0f) / size;

      }

    return chances;

    }

// PUBLIC API

    {

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

    {

    return 4;

    }

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

    }

  public int randomizeNewRotAxis(Random rnd, int oldRotAxis)

    {

    int numAxis = ROTATION_AXIS.length;

    if( oldRotAxis == START_AXIS )

      }

    else

      {

      int newVector = rnd.nextInt(numAxis-1);

      return (newVector>=oldRotAxis ? newVector+1 : newVector);

    }

    for(int row=0; row<mRowChances.length; row++)

      {

      if( rowFloat<=mRowChances[row] ) return row;

      }

    return 0;

  public boolean isSolved()

    {

    int index = CUBITS[0].mQuatIndex;

    for(int i=1; i<NUM_CUBITS; i++)

      {

      if( !thereIsNoVisibleDifference(CUBITS[i], index) ) return false;

      }

    return true;

    }

// return if the Cubit, when rotated with its own mQuatScramble, would have looked any different

// then if it were rotated by quaternion 'quat'.

// No it is not so simple as the quats need to be the same - imagine a 4x4x4 cube where the two

// middle squares get interchanged. No visible difference!

//

// So: this is true iff the cubit

// a) is a corner or edge and the quaternions are the same

// b) is inside one of the faces and after rotations by both quats it ends up on the same face.

    if ( cubit.mQuatIndex == quatIndex ) return true;

    int belongsToHowManyFaces = 0;

    int size = getSize()-1;

    float row;

    final float MAX_ERROR = 0.01f;

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

      {

      row = cubit.mRotationRow[i];

      if( (row     <MAX_ERROR && row     >-MAX_ERROR) ||

          (row-size<MAX_ERROR && row-size>-MAX_ERROR)  ) belongsToHowManyFaces++;

      }

    switch(belongsToHowManyFaces)

      {

      case 0 : return true ;  // 'inside' cubit that does not lie on any face

      case 1 :                // cubit that lies inside one of the faces

               Static3D orig = cubit.getOrigPosition();

               Static4D quat1 = QUATS[quatIndex];

               Static4D quat2 = QUATS[cubit.mQuatIndex];

               Static4D cubitCenter = new Static4D( orig.get0(), orig.get1(), orig.get2(), 0);

               Static4D rotated1 = RubikSurfaceView.rotateVectorByQuat( cubitCenter, quat1 );

               Static4D rotated2 = RubikSurfaceView.rotateVectorByQuat( cubitCenter, quat2 );

               float row1, row2, row3, row4;

               float ax,ay,az;

               Static3D axis;

               float x1 = rotated1.get0();

               float y1 = rotated1.get1();

               float z1 = rotated1.get2();

               float x2 = rotated2.get0();

               float y2 = rotated2.get1();

               float z2 = rotated2.get2();

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

                 {

                 axis = ROTATION_AXIS[i];

                 ax = axis.get0();

                 ay = axis.get1();

                 az = axis.get2();

                 row1 = ((x1*ax + y1*ay + z1*az) - mStart) / mStep;

                 row2 = ((x2*ax + y2*ay + z2*az) - mStart) / mStep;

                 row3 = row1 - size;

                 row4 = row2 - size;

                 if( (row1<MAX_ERROR && row1>-MAX_ERROR && row2<MAX_ERROR && row2>-MAX_ERROR) ||

                     (row3<MAX_ERROR && row3>-MAX_ERROR && row4<MAX_ERROR && row4>-MAX_ERROR)  )

                   {

                   return true;

                   }

                 }

               return false;

      default: return false;  // edge or corner

      }

    }

// (because the first implemented Solver - the two-phase Cube3 one - expects such order)

//

//

// Up    :   index --> b<s-1 ? (s-1)*(s+4b)+a : 6*s*s -13*s +8 +a

//                     if b==s-1: 6*s*s -11*s +6 - index

//                     else

//                         a==0: s*s + s-1 + 4*(b-1)*(s-1) + 2*(s-2) + s

//                         else: s*s + s-1 + 4*(b-1)*(s-1) + 2*(s-1-a)

// Down  :   index --> b==0 ? (s-1-a) : s*s + s-1 + 4*(b-1)*(s-1) - a

// Left  :   index --> (s-1-a)*s + b

// Back  :   index --> if b==s-1: s*(s-1-a)

//                     if b==0  : 5*s*s -12*s + 8 + (s-1-a)*s

//                     else

//                        if a==s-1: s*s + 4*(s-2-b)*(s-1)

//                        else     : s*s + 4*(s-2-b)*(s-1) + s + (s-2-a)*2

    int size = getSize();

    int len = size*size;

    int color=-1, face=-1;

    final int RIGHT= 0;

    final int LEFT = 1;

    final int UP   = 2;

    final int DOWN = 3;

    final int FRONT= 4;

    final int BACK = 5;

    final char[] FACE_NAMES = { 'R', 'L', 'U', 'D', 'F', 'B', 'I'};

    face = UP;

      {

      row = i/size;

      col = i%size;

      cubitIndex = col<size-1 ? (size-1)*(size+4*col) + row : 6*size*size - 13*size + 8 + row;

      }

      {

      cubitIndex = 6*size*size - 12*size +7 - i;

      }

      {

      row = i/size;

      col = i%size;

      if( col==size-1 ) cubitIndex = 6*size*size - 11*size + 6 -i;

      else if( col==0 ) cubitIndex = size*size - 1 - i;

      else

        {

        if( row==0 ) cubitIndex = size*size + size-1 + 4*(col-1)*(size-1) + 2*(size-2) + size;

        else         cubitIndex = size*size + size-1 + 4*(col-1)*(size-1) + 2*(size-1-row);

        }

      }

      {

      row = i/size;

      col = i%size;

      cubitIndex = col==0 ? size-1-row : size*size + size-1 + 4*(col-1)*(size-1) - row;

      }