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.main.DistortedEffects;

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)

         };

           COLOR_BLUE  , COLOR_GREEN,

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

             MeshSquare mesh, DistortedEffects effects, int[][] moves, Resources res, int scrWidth)

  MeshBase createCubitMesh(int cubit)

    {

    if( mMeshes==null )

      {

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

      }

    int ordinal= ObjectList.CUBE.ordinal();

    if( mMeshes[index]==null )

      {

    return mMeshes[index].copy(true);

    }

    float R = 0.10f;

    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 )

    }

  boolean shouldResetTextureMaps()

    {

    return false;

    }

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

      {

      cuts[i] = (2-size)*0.5f + i;

      }

    return cuts;

  int getNumStickerTypes()

    {

    return 1;

    }

  int getNumCubitFaces()

    {

    return FACE_COLORS.length;

  float getScreenRatio()

    {

    return 0.5f;

    }

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

    {

    return diff*diff < 0.0001f ? cubitface : NUM_FACES;

  float returnMultiplier()

    {

  float[] getRowChances()

    {

    float[] chances = new float[numLayers];

    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;

    final float MAX_ERROR = 0.01f;

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

      {

      row = cubit.mRotationRow[i];

          (row-lastLayer<MAX_ERROR && row-lastLayer>-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 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++)

                 {

                 row2 = computeRow(x2,y2,z2,i);

               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 len = layers*layers;

    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;

      {

      col = i%layers;

      }

      {

      }

      {

      col = i%layers;

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

        {

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

      }

      {

      col = i%layers;

      }

      {

      col = i%layers;

      }

      {

      col = i%layers;

      else if(   col==0 ) cubitIndex = 5*layers*layers - 12*layers + 8 + (layers-1-row)*layers;

        {

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

      }

    return objectString.toString();

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

  public int getObjectName(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return R.string.cube2;

      case 3: return R.string.cube3;

      case 4: return R.string.cube4;

      case 5: return R.string.cube5;

      }

    return R.string.cube3;

    }

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

  public int getInventor(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return R.string.cube2_inventor;

      case 3: return R.string.cube3_inventor;

      case 4: return R.string.cube4_inventor;

      case 5: return R.string.cube5_inventor;

      }

    return R.string.cube3_inventor;

    }

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

  public int getComplexity(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return 4;

      case 3: return 6;

      case 4: return 8;

      case 5: return 10;

      }

    return 6;

    }