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.helpers.FactoryCubit;

import org.distorted.helpers.FactorySticker;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.effect.VertexEffectMove;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.effect.VertexEffectScale;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.mesh.MeshPolygon;

import org.distorted.library.mesh.MeshSquare;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

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

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 float[][] getPositions();

  abstract int[] getQuatIndices();

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

  int getCubitVariant(int cubit)

    {

    float[][] pos = getPositions();

    if( cubit>=0 && cubit< pos.length )

      {

      int numPoints = pos[cubit].length/3;

      return numPoints==8 ? 4 : numPoints-1;

      }

    return 1;

    }

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

  int getNumCubits()

    {

    return getPositions().length;

    }

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

  float[] getCubitPosition(int cubit)

    {

    float[][] pos = getPositions();

    return ( cubit>=0 && cubit< pos.length ) ? pos[cubit] : null;

    }

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

  private int getQuatIndex(int cubit)

    {

    int[] indices = getQuatIndices();

    return ( cubit>=0 && cubit< indices.length ) ? indices[cubit] : 0;

    }

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

  private float[] createVertices(int A, int B)

    {

    float E = 0.5f / Math.max(A,B);

    return new float[] { -A*E,-B*E, +A*E,-B*E, +A*E,+B*E, -A*E,+B*E };

    }

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

  private MeshBase createCuboid(int[] dimensions)

    {

    FactoryCubit factory = FactoryCubit.getInstance();

    int X = dimensions[0];

    int Y = dimensions[1];

    int Z = dimensions[2];

    float[] verticesXY = createVertices(X,Y);

    float[] verticesXZ = createVertices(X,Z);

    float[] verticesYZ = createVertices(Z,Y);

    float defHeight = 0.048f;

    float[] bandsX = factory.computeBands( defHeight/X,65,0.25f,0.5f,5);

    float[] bandsY = factory.computeBands( defHeight/Y,65,0.25f,0.5f,5);

    float[] bandsZ = factory.computeBands( defHeight/Z,65,0.25f,0.5f,5);

    MeshBase[] meshes = new MeshPolygon[6];

    meshes[0] = new MeshPolygon(verticesYZ,bandsX,1,2);

    meshes[0].setEffectAssociation(0,1,0);

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

    meshes[1].setEffectAssociation(0,2,0);

    meshes[2] = new MeshPolygon(verticesXZ,bandsY,1,2);

    meshes[2].setEffectAssociation(0,4,0);

    meshes[3] = meshes[2].copy(true);

    meshes[3].setEffectAssociation(0,8,0);

    meshes[4] = new MeshPolygon(verticesXY,bandsZ,1,2);

    meshes[4].setEffectAssociation(0,16,0);

    meshes[5] = meshes[4].copy(true);

    meshes[5].setEffectAssociation(0,32,0);

    return new MeshJoined(meshes);

    }

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

  private VertexEffect[] createCuboidEffects(int[] dimensions)

    {

    float X = dimensions[0];

    float Y = dimensions[1];

    float Z = dimensions[2];

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

    float MAX_XZ = Math.max(X,Z);

    float MAX_YZ = Math.max(Z,Y);

    Static1D angle = new Static1D(90);

    Static3D move  = new Static3D( 0.0f, 0.0f, 0.5f);

    Static3D axisX = new Static3D( 1.0f, 0.0f, 0.0f);

    Static3D axisY = new Static3D( 0.0f, 1.0f, 0.0f);

    Static3D center= new Static3D( 0.0f, 0.0f, 0.0f);

    Static3D scale3 = new Static3D(MAX_XY,MAX_XY,+Z);

    Static3D scale4 = new Static3D(MAX_XY,MAX_XY,-Z);

    Static3D scale5 = new Static3D(MAX_XZ,+Y,MAX_XZ);

    Static3D scale6 = new Static3D(MAX_XZ,-Y,MAX_XZ);

    Static3D scale7 = new Static3D(+X,MAX_YZ,MAX_YZ);

    Static3D scale8 = new Static3D(-X,MAX_YZ,MAX_YZ);

    VertexEffect[] effect = new VertexEffect[9];

    effect[0] = new VertexEffectMove(move);

    effect[1] = new VertexEffectRotate(angle, axisX, center);

    effect[2] = new VertexEffectRotate(angle, axisY, center);

    effect[3] = new VertexEffectScale(scale3);

    effect[4] = new VertexEffectScale(scale4);

    effect[5] = new VertexEffectScale(scale5);

    effect[6] = new VertexEffectScale(scale6);

    effect[7] = new VertexEffectScale(scale7);

    effect[8] = new VertexEffectScale(scale8);

    effect[1].setMeshAssociation(12,-1);  // meshes 2,3

    effect[2].setMeshAssociation( 3,-1);  // meshes 0,1

    effect[3].setMeshAssociation(16,-1);  // mesh 4

    effect[4].setMeshAssociation(32,-1);  // mesh 5

    effect[5].setMeshAssociation( 8,-1);  // mesh 3

    effect[6].setMeshAssociation( 4,-1);  // mesh 2

    effect[7].setMeshAssociation( 1,-1);  // mesh 0

    effect[8].setMeshAssociation( 2,-1);  // mesh 1

    return effect;

    }

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

  private MeshBase createCuboidMesh(int[] dimensions)

    {

    MeshBase mesh = createCuboid(dimensions);

    VertexEffect[] effects = createCuboidEffects(dimensions);

    for( VertexEffect effect : effects ) mesh.apply(effect);

    int X = dimensions[0];

    int Y = dimensions[1];

    int Z = dimensions[2];

    float strength = 0.04f;

    float radius   = 0.15f;

    Static3D[] vertices = new Static3D[1];

    Static3D center;

    FactoryCubit factory = FactoryCubit.getInstance();

    vertices[0] = new Static3D(+0.5f*X,+0.5f*Y,+0.5f*Z);

    center = new Static3D(+0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(+0.5f*X,+0.5f*Y,-0.5f*Z);

    center = new Static3D(+0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(+0.5f*X,-0.5f*Y,+0.5f*Z);

    center = new Static3D(+0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(+0.5f*X,-0.5f*Y,-0.5f*Z);

    center = new Static3D(+0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(-0.5f*X,+0.5f*Y,+0.5f*Z);

    center = new Static3D(-0.5f*(X-1),+0.5f*(Y-1),+0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(-0.5f*X,+0.5f*Y,-0.5f*Z);

    center = new Static3D(-0.5f*(X-1),+0.5f*(Y-1),-0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(-0.5f*X,-0.5f*Y,+0.5f*Z);

    center = new Static3D(-0.5f*(X-1),-0.5f*(Y-1),+0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    vertices[0] = new Static3D(-0.5f*X,-0.5f*Y,-0.5f*Z);

    center = new Static3D(-0.5f*(X-1),-0.5f*(Y-1),-0.5f*(Z-1));

    factory.roundCorners(mesh, center, vertices, strength, radius);

    mesh.mergeEffComponents();

    return mesh;

    }

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

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

    }

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

  float[][] getCubitPositions(int size)

    {

    int numCubits = getNumCubits();

    float[][] tmp = new float[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)

    {

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

    float position = 0.0f;

    int len = pos.length/3;

    for(int i=0; i<len; i++) position += pos[3*i+posIndex];

    position /= len;

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

    return reaches ? stickerIndex*NUM_FACES + face : NUM_STICKERS*NUM_FACES;

    }

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

  int computeBitmapFromRow(int rowBitmap, int axis)

    {

    int bitmap, initBitmap=0;

    while( initBitmap!=rowBitmap )

      {

      initBitmap = rowBitmap;

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

        {

        bitmap = CUBITS[cubit].mRotationRow[axis];

        if( (rowBitmap & bitmap) != 0 ) rowBitmap |= bitmap;

        }

      }

    return rowBitmap;

    }

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

  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;

    }

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

  public boolean isSolved()

    {

    int index = CUBITS[0].mQuatIndex;

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

      {

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

      }

    return true;

    }

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

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

  public String retObjectString()

    {

    return "";

    }

}