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

         };

  private 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 final int[][] mDimensions = new int[][]

        {

         {1,1,1},  // has to be X>=Z>=Y so that all

         {2,1,1},  // the faces are horizontal

         {3,1,1},

         {2,1,2},

         {2,2,2}

        };

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

        {

         {1,1},  // dimensions of the faces of

         {2,1},  // the cuboids defined above

         {3,1},

         {2,2}

        };

  private static final int[][] mFaceMap = new int[][] // cubitface=2 when rotated by

    {                                                 // quatIndex=1 gets moved to

        {0,0,5,2,4,2},                                // position mFaceMap[2][1]

        {1,1,4,3,5,3},

        {2,4,2,1,1,4},

        {3,5,3,0,0,5},

        {4,3,0,4,3,0},

        {5,2,1,5,2,1}

    };

  private static final int[][] mAxisMap = new int[][] // axis=1 when rotated by

    {                                                 // quatIndex=2 gets moved to

        {0,0,2,1,2,1},                                // axis mAxisMap[1][2]

        {1,2,1,0,0,2},

        {2,1,0,2,1,0}

    };

  private static final int NUM_STICKERS = mStickerDimensions.length;

  private static MeshBase[] mMeshes;

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

  TwistyBandagedAbstract(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 getCubitVariant(int cubit);

  abstract int getNumCubits();

  abstract int getQuatIndex(int cubit);

  abstract float[] getCubitPosition(int cubit);

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

  MeshBase createCubitMesh(int cubit, int numLayers)

    {

    if( mMeshes==null )

      {

      int LEN = mDimensions.length;

      mMeshes = new MeshBase[LEN];

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

        {

        mMeshes[i] = FactoryCubit.getInstance().createCuboidMesh(mDimensions[i]);

        }

      }

    int variant = getCubitVariant(cubit);

    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;

    }

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

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

    {

    int numFaces = FACE_COLORS.length;

    int stickerType = face/numFaces;

    int color = face%numFaces;

    float X = mStickerDimensions[stickerType][0];

    float Y = mStickerDimensions[stickerType][1];

    float MAX = Math.max(X,Y);

    float R = 0.10f / MAX;

    float S = 0.08f / MAX;

    X /= (2*MAX);

    Y /= (2*MAX);

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

    FactorySticker factory = FactorySticker.getInstance();

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

    }

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

  Static3D[] getCubitPositions(int size)

    {

    int numCubits = getNumCubits();

    Static3D[] tmp = new Static3D[numCubits];

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

      {

      float[] pos = getCubitPosition(cubit);

      tmp[cubit] = new Static3D(pos[0],pos[1],pos[2]);

      }

    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)

    {

    return NUM_STICKERS;

    }

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

  int getNumCubitFaces()

    {

    return FACE_COLORS.length;

    }

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

  float getScreenRatio()

    {

    return 0.5f;

    }

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

  private int retStickerIndex(int horzSize, int vertSize)

    {

    switch(horzSize)

      {

      case 1: return 0;

      case 2: return vertSize==1 ? 1:3;

      case 3: return 2;

      }

    return 0;

    }

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

  private int getStickerIndex(int cubitface, int[] dim)

    {

    switch(cubitface)

      {

      case 0: case 1: return retStickerIndex(dim[2],dim[1]);

      case 2: case 3: return retStickerIndex(dim[0],dim[2]);

      case 4: case 5: return retStickerIndex(dim[0],dim[1]);

      }

    return 0;

    }

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

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

    {

    int variant      = getCubitVariant(cubit);

    int[] dim        = mDimensions[variant];

    float[] pos      = getCubitPosition(cubit);

    int stickerIndex = getStickerIndex(cubitface,dim);

    int quatIndex    = getQuatIndex(cubit);

    int face         = mFaceMap[cubitface][quatIndex];

    int multiplier   = (face%2)==0 ? 1:-1;

    int posIndex     = face/2;

    int dimIndex     = mAxisMap[posIndex][quatIndex];

    boolean reaches  = multiplier*pos[posIndex] + dim[dimIndex]*0.5f > (numLayers-1)*0.5f;

    int ret=  reaches ? stickerIndex*NUM_FACES + face : NUM_STICKERS*NUM_FACES;

if( cubit==0 )

  {

android.util.Log.e("DISTORTED", "cubit="+cubit+" cubitface="+cubitface+" ret="+ret+" stickerIndex="+stickerIndex+" face="+face);

android.util.Log.e("DISTORTED", "reaches="+reaches+" border="+((numLayers-1)*0.5f)+" left="+(multiplier*pos[posIndex] + dim[dimIndex]*0.5f));

android.util.Log.e("DISTORTED", "posIndex="+posIndex+" dimIndex="+dimIndex);

  }

    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 Bandaged solvers ATM)

  public String retObjectString()

    {

    return "";

    }

}