Magic Cube

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

// Copyright 2021 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

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

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

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

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

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.objects;

import android.content.res.Resources;

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshSquare;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.main.RubikSurfaceView;

import java.util.Random;

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

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

abstract class TwistyBandagedCube extends TwistyObject

{

  // the three rotation axis of a 3x3 Cube. Must be normalized.

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

  private static final int[] FACE_COLORS = new int[]

         {

           COLOR_YELLOW, COLOR_WHITE,

           COLOR_BLUE  , COLOR_GREEN,

           COLOR_RED   , COLOR_ORANGE

         };

  private static final Static4D[] QUATS = new Static4D[]

         {

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

         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)

         };

  // possible aspectRatios of cubit faces in case of a bandaged 3x3:

  // 1/3, 1/2, 2/3, 1, 3/2, 2, 3. Numerator = (1/3)*3!, (1/2)*3!, ...

  private static final int[] mAspectNumerator3 = new int[] {2,3,4,6,9,12,18};

  private static final int[] mAspectRatio3     = new int[] {0,0,0,0,0,0,0};

  static final Static4D[] INIT_QUATS = new Static4D[]

        {

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

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

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

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

        new Static4D( -0.5f,  +0.5f,  -0.5f,  -0.5f),  // ZX

        new Static4D( +0.5f,  +0.5f,  +0.5f,  +0.5f),  // YX

        };

  private static MeshBase[] mMeshes;

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

  TwistyBandagedCube(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh,

                     DistortedEffects effects, int[][] moves, ObjectList list, Resources res, int scrWidth)

    {

    super(size, size, quat, texture, mesh, effects, moves, list, res, scrWidth);

    }

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

  abstract int getNumCubitVariants();

  abstract int getCubitVariant(int cubit);

  abstract int getNumCubits();

  abstract int[] getCubitDimensions(int variant);

  abstract Static3D getCubitPosition(int cubit);

  abstract int getQuatIndex(int cubit);

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

  MeshBase createCubitMesh(int cubit, int numLayers)

    {

    if( mMeshes==null )

      {

      mMeshes = new MeshBase[getNumCubitVariants()];

      }

    int variant = getCubitVariant(cubit);

    if( mMeshes[variant]==null )

      {

      int[] dimensions = getCubitDimensions(variant);

      mMeshes[variant] = FactoryCubit.getInstance().createCuboidMesh(dimensions);

      }

    MeshBase mesh = mMeshes[variant].copy(true);

    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( INIT_QUATS[getQuatIndex(cubit)], new Static3D(0,0,0) );

    mesh.apply(quat,0xffffffff,0);

    return mesh;

    }

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

  private int getAspectNumerator(int stickerType)

    {

    int type=-1;

    int len = mAspectRatio3.length;

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

      {

      if( mAspectRatio3[i] != 0 ) type++;

      if( type==stickerType ) return mAspectNumerator3[i];

      }

    return 0;

    }

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

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

    {

    float R = 0.10f;

    float S = 0.08f;

    int numFaces = FACE_COLORS.length;

    int stickerType = face/numFaces;

    float ratio = getAspectNumerator(stickerType)/6.0f;

    float X,Y;

    if( ratio<1.0f )

      {

      X = ratio/2;

      Y = 0.5f;

      }

    else

      {

      X = 0.5f;

      Y = 0.5f/ratio;

      }

    float[] vertices = { -X,-Y, +X,-Y, +X,+Y, -X,+Y};

    FactorySticker factory = FactorySticker.getInstance();

    factory.drawRoundedPolygon(canvas, paint, left, top, vertices, S, FACE_COLORS[face%numFaces], R);

    }

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

  Static3D[] getCubitPositions(int size)

    {

    int numCubits = getNumCubits();

    Static3D[] tmp = new Static3D[numCubits];

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

      {

      tmp[cubit] = getCubitPosition(cubit);

      }

    return tmp;

    }

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

  Static4D[] getQuats()

    {

    return QUATS;

    }

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

  boolean shouldResetTextureMaps()

    {

    return false;

    }

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

  int getNumFaces()

    {

    return FACE_COLORS.length;

    }

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

  float[] getCuts(int numLayers)

    {

    float[] cuts = new float[numLayers-1];

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

      {

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

      }

    return cuts;

    }

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

  int getNumStickerTypes(int numLayers)

    {

    if( numLayers==3 )

      {

      int numVariants = getNumCubitVariants();

      int len = mAspectNumerator3.length;

      for(int variant=0; variant<numVariants; variant++)

        {

        int[] dimensions = getCubitDimensions(variant);

        int ratio0 = 6*dimensions[0]/dimensions[1];

        int ratio1 = 6*dimensions[0]/dimensions[2];

        int ratio2 = 6*dimensions[2]/dimensions[1];

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

          {

          if( mAspectNumerator3[i]==ratio0 ||

              mAspectNumerator3[i]==ratio1 ||

              mAspectNumerator3[i]==ratio2  ) mAspectRatio3[i]++;

          }

        }

      int result=0;

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

        {

        if( mAspectRatio3[i]>0 ) result++;

        }

      return result;

      }

    return 1;

    }

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

  int getNumCubitFaces()

    {

    return FACE_COLORS.length;

    }

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

  float getScreenRatio()

    {

    return 0.5f;

    }

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

  int getFaceColor(int cubit, int cubitface, int numLayers)

    {

    int X=0,Y=0,Z=0;

    int variant = getCubitVariant(cubit);

    int[] dim = getCubitDimensions(variant);

    Static3D pos = getCubitPosition(cubit);

    switch( getQuatIndex(cubit) )

      {

      case 0: X= dim[0]; Y=dim[1]; Z=dim[2]; break;

      case 1: X= dim[0]; Y=dim[2]; Z=dim[1]; break;

      case 2: X= dim[2]; Y=dim[1]; Z=dim[0]; break;

      case 3: X= dim[1]; Y=dim[0]; Z=dim[2]; break;

      case 4: X= dim[1]; Y=dim[2]; Z=dim[0]; break;

      case 5: X= dim[2]; Y=dim[0]; Z=dim[1]; break;

      }

    float posX = pos.get0();

    float posY = pos.get1();

    float posZ = pos.get2();

    float border = (numLayers-1)*0.5f;

    int ret = NUM_FACES;

    switch(cubitface)

      {

      case 0: ret = posX + X*0.5f > border ? cubitface : NUM_FACES; break;

      case 1: ret = posX - X*0.5f <-border ? cubitface : NUM_FACES; break;

      case 2: ret = posY + Y*0.5f > border ? cubitface : NUM_FACES; break;

      case 3: ret = posY - Y*0.5f <-border ? cubitface : NUM_FACES; break;

      case 4: ret = posZ + Z*0.5f > border ? cubitface : NUM_FACES; break;

      case 5: ret = posZ - Z*0.5f <-border ? cubitface : NUM_FACES; break;

      }

    return ret;

    }

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

  float returnMultiplier()

    {

    return getNumLayers();

    }

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

  float[] getRowChances(int numLayers)

    {

    float[] chances = new float[numLayers];

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

      {

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

      }

    return chances;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int getBasicAngle()

    {

    return 4;

    }

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

// TODO

  public int randomizeNewRotAxis(Random rnd, int oldRotAxis)

    {

    int numAxis = ROTATION_AXIS.length;

    if( oldRotAxis == START_AXIS )

      {

      return rnd.nextInt(numAxis);

      }

    else

      {

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

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

      }

    }

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

// TODO

  public int randomizeNewRow(Random rnd, int oldRotAxis, int oldRow, int newRotAxis)

    {

    float rowFloat = rnd.nextFloat();

    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.

  private boolean thereIsNoVisibleDifference(Cubit cubit, int quatIndex)

    {

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

    int belongsToHowManyFaces = 0;

    int lastLayer = getNumLayers()-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-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 row1, row2;

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

                 {

                 row1 = computeRow(x1,y1,z1,i);

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

                 if( (row1==0 && row2==0) || (row1==lastLayer && row2==lastLayer) ) return true;

                 }

               return false;

      default: return false;  // edge or corner

      }

    }

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

// only needed for solvers - there are no Ivy solvers ATM)

  public String retObjectString()

    {

    return "";

    }

}