Magic Cube

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

// Copyright 2019 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.VertexEffectDeform;

import org.distorted.library.effect.VertexEffectMove;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.effect.VertexEffectSink;

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;

import org.distorted.main.RubikSurfaceView;

import java.util.Random;

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

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

public class RubikPyraminx extends RubikObject

{

  private static final float SQ2 = (float)Math.sqrt(2);

  private static final float SQ3 = (float)Math.sqrt(3);

  private static final float SQ6 = (float)Math.sqrt(6);

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(         0,        1,       0 ),

           new Static3D(         0,  -1.0f/3, 2*SQ2/3 ),

           new Static3D(-SQ2*SQ3/3,  -1.0f/3,  -SQ2/3 ),

           new Static3D( SQ2*SQ3/3,  -1.0f/3,  -SQ2/3 )

         };

  static final Static3D[] FACE_AXIS = new Static3D[]

         {

           new Static3D(         0,      -1,       0 ),

           new Static3D(         0,  1.0f/3,-2*SQ2/3 ),

           new Static3D( SQ2*SQ3/3,  1.0f/3,   SQ2/3 ),

           new Static3D(-SQ2*SQ3/3,  1.0f/3,   SQ2/3 )

         };

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

         {

           0xff00ff00, 0xffffff00,  // FACE_AXIS[0] (GREEN ) FACE_AXIS[1] (YELLOW )

           0xff0000ff, 0xffff0000   // FACE_AXIS[2] (BLUE  ) FACE_AXIS[3] (RED    )

         };

  // computed with res/raw/compute_quats.c

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

         {

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

           new Static4D(  0.0f,  SQ3/2,   0.0f,  0.5f),

           new Static4D( SQ2/2, -SQ3/6, -SQ6/6,  0.5f),

           new Static4D(-SQ2/2, -SQ3/6, -SQ6/6,  0.5f),

           new Static4D(  0.0f, -SQ3/6,  SQ6/3,  0.5f),

           new Static4D(  0.0f,  SQ3/2,   0.0f, -0.5f),

           new Static4D( SQ2/2, -SQ3/6, -SQ6/6, -0.5f),

           new Static4D(-SQ2/2, -SQ3/6, -SQ6/6, -0.5f),

           new Static4D(  0.0f, -SQ3/6,  SQ6/3, -0.5f),

           new Static4D( SQ2/2, -SQ3/3,  SQ6/6,  0.0f),

           new Static4D(  0.0f, -SQ3/3, -SQ6/3,  0.0f),

           new Static4D(-SQ2/2, -SQ3/3,  SQ6/6,  0.0f)

         };

  private int[] mRotArray;

  private static VertexEffectRotate[] ROTATION;

  private static MeshBase mMesh =null;

  private static MeshBase[] mMeshRotated = new MeshBase[ROT_AXIS.length];

  static

    {

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

    Static1D angle  = new Static1D(180.0f);

    ROTATION = new VertexEffectRotate[ROT_AXIS.length];

    for(int i = 0; i< ROT_AXIS.length; i++)

      {

      ROTATION[i] = new VertexEffectRotate( angle, ROT_AXIS[i], center);

      mMeshRotated[i] = null;

      }

    }

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

  RubikPyraminx(int size, Static4D quat, DistortedTexture texture,

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

    {

    super(size, 30, quat, texture, mesh, effects, moves, RubikObjectList.PYRA, res, scrWidth);

    }

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

  private void emitRow(float x, float y, float z, float dx, float dy, float dz, int n, int rot, Static3D[] array, int index)

    {

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

      {

      mRotArray[i+index] = rot;

      array[i+index] = new Static3D(x+0.5f,y+SQ2*SQ3/12,z+SQ3/6);

      x += dx;

      y += dy;

      z += dz;

      }

    }

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

  private int emitLowermost(float x, float y, float z, int n, Static3D[] array)

    {

    int added = 0;

    emitRow( x      +0.5f, y+SQ3*SQ2/9, z+ SQ3/18,  1.0f, 0,     0, n-1, 1, array, added);

    added += (n-1);

    emitRow( x    +1.0f/3, y+SQ3*SQ2/9, z+2*SQ3/9,  0.5f, 0, SQ3/2, n-1, 3, array, added);

    added += (n-1);

    emitRow( x+n-1-1.0f/3, y+SQ3*SQ2/9, z+2*SQ3/9, -0.5f, 0, SQ3/2, n-1, 2, array, added);

    added += (n-1);

    for(int i=n; i>=1; i--)

      {

      emitRow(x     , y, z      , 1,0,0, i  , -1, array, added);

      added += i;

      emitRow(x+0.5f, y, z+SQ3/6, 1,0,0, i-1,  0, array, added);

      added += (i-1);

      x += 0.5f;

      y += 0.0f;

      z += SQ3/2;

      }

    return added;

    }

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

  private int emitUpper(float x, float y, float z, int n, Static3D[] array, int index)

    {

    if( n>1 )

      {

      emitRow( x           , y          , z        ,  1.0f, 0,     0, n-1, -1, array, index);

      index += (n-1);

      emitRow( x+0.5f      , y+SQ3*SQ2/9, z+SQ3/18 ,  1.0f, 0,     0, n-1,  1, array, index);

      index += (n-1);

      emitRow( x+0.5f      , y          , z+SQ3/2  ,  0.5f, 0, SQ3/2, n-1, -1, array, index);

      index += (n-1);

      emitRow( x    +1.0f/3, y+SQ3*SQ2/9, z+2*SQ3/9,  0.5f, 0, SQ3/2, n-1,  3, array, index);

      index += (n-1);

      emitRow( x+n-1       , y          , z        , -0.5f, 0, SQ3/2, n-1, -1, array, index);

      index += (n-1);

      emitRow( x+n-1-1.0f/3, y+SQ3*SQ2/9, z+2*SQ3/9, -0.5f, 0, SQ3/2, n-1,  2, array, index);

      index += (n-1);

      }

    else

      {

      mRotArray[index] = -1;

      array[index] = new Static3D(x+0.5f,y+SQ2*SQ3/12,z+SQ3/6);

      index++;

      }

    return index;

    }

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

// size^2 + 3*(size-1) in the lowermost layer, then 6*(size-2) in the next, 6*(size-3) in the next,

// ... 6 in the forelast, 1 in the last = 4size^2 - 6size +4 (if size>1)

  Static3D[] getCubitPositions(int size)

    {

    int numCubits = size>1 ? 4*size*size - 6*size +4 : 1;

    Static3D[] tmp = new Static3D[numCubits];

    mRotArray = new int[numCubits];

    int currentIndex = emitLowermost( -0.5f*size, -(SQ2*SQ3/12)*size, -(SQ3/6)*size, size, tmp);

    for(int i=size-1; i>=1; i--)

      {

      currentIndex = emitUpper( -0.5f*i, ((SQ2*SQ3)/12)*(3*size-4*i), -(SQ3/6)*i, i, tmp, currentIndex);

      }

    return tmp;

    }

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

  Static4D[] getQuats()

    {

    return QUATS;

    }

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

  int getNumFaces()

    {

    return FACE_COLORS.length;

    }

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

  int getNumCubitFaces()

    {

    return FACE_COLORS.length;

    }

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

  float getScreenRatio()

    {

    return 0.82f;

    }

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

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

    {

    boolean belongs = isOnFace(cubit, cubitface, 0 );

    return belongs ? cubitface : NUM_FACES;

    }

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

  private MeshBase createStaticMesh(int cubit)

    {

    final float SQ2 = (float)Math.sqrt(2);

    final float SQ3 = (float)Math.sqrt(3);

    final float angleFaces = (float)((180/Math.PI)*(2*Math.asin(SQ3/3))); // angle between two faces of a tetrahedron

    final int MESHES=4;

    int size = getSize();

    int association = 1;

    float D = 0.0005f;

    float E = SQ3/2 - 3*D*SQ2;

    float F = 0.5f - D*SQ2*SQ3;

    float[] bands;

    int extraI, extraV;

    float[] vertices = { -F,-E/3, +F,-E/3, 0.0f,2*E/3};

    switch(size)

      {

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

                                     1.0f  -D,-D*0.80f,

                                     1.0f-2*D,-D*0.65f,

                                     1.0f-4*D,+D*0.10f,

                                     0.50f, 0.035f,

                                     0.0f, 0.040f };

                      extraI = 2;

                      extraV = 2;

                      break;

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

                                     1.0f-D*1.2f,-D*0.70f,

                                     1.0f-3*D, -D*0.15f,

                                     0.50f, 0.035f,

                                     0.0f, 0.040f };

                      extraI = 2;

                      extraV = 2;

                      break;

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

                                     1.0f-D*1.2f,-D*0.70f,

                                     1.0f-3*D, -D*0.15f,

                                     0.50f, 0.035f,

                                     0.0f, 0.040f };

                      extraI = 2;

                      extraV = 1;

                      break;

      }

    MeshBase[] meshes = new MeshPolygon[MESHES];

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

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

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

      {

      association <<= 1;

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

      meshes[i].setEffectAssociation(0,association,0);

      }

    MeshBase result = new MeshJoined(meshes);

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

    Static3D a1 = new Static3D(         0,  -1.0f/3, 2*SQ2/3 );

    Static3D a2 = new Static3D(-SQ2*SQ3/3,  -1.0f/3,  -SQ2/3 );

    Static3D a3 = new Static3D( SQ2*SQ3/3,  -1.0f/3,  -SQ2/3 );

    float tetraHeight = SQ2*SQ3/3;

    float d1 = (0.75f-2*SQ2*D)*tetraHeight;

    float d2 =-0.06f*tetraHeight;

    float d3 = 0.05f*tetraHeight;

    float d4 = 0.70f*tetraHeight;

    float d5 = 1.2f;

    Static3D dCen0 = new Static3D( d1*a0.get0(), d1*a0.get1(), d1*a0.get2() );

    Static3D dCen1 = new Static3D( d1*a1.get0(), d1*a1.get1(), d1*a1.get2() );

    Static3D dCen2 = new Static3D( d1*a2.get0(), d1*a2.get1(), d1*a2.get2() );

    Static3D dCen3 = new Static3D( d1*a3.get0(), d1*a3.get1(), d1*a3.get2() );

    Static3D dVec0 = new Static3D( d2*a0.get0(), d2*a0.get1(), d2*a0.get2() );

    Static3D dVec1 = new Static3D( d2*a1.get0(), d2*a1.get1(), d2*a1.get2() );

    Static3D dVec2 = new Static3D( d2*a2.get0(), d2*a2.get1(), d2*a2.get2() );

    Static3D dVec3 = new Static3D( d2*a3.get0(), d2*a3.get1(), d2*a3.get2() );

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

    Static1D dRad  = new Static1D(1);

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

    Static4D sReg  = new Static4D(0,0,0,d4);

    Static1D sink  = new Static1D(d5);

    Static1D angle  = new Static1D(angleFaces);

    Static3D axis1  = new Static3D(  -1, 0,      0);

    Static3D axis2  = new Static3D(0.5f, 0, -SQ3/2);

    Static3D axis3  = new Static3D(0.5f, 0, +SQ3/2);

    Static3D center1= new Static3D(0,-SQ3*SQ2/12,-SQ3/6);

    Static3D center2= new Static3D(0,-SQ3*SQ2/12,+SQ3/3);

    VertexEffectRotate  effect1 = new VertexEffectRotate( new Static1D(90), new Static3D(1,0,0), center );

    VertexEffectMove    effect2 = new VertexEffectMove  ( new Static3D(0,-SQ3*SQ2/12,0) );

    VertexEffectRotate  effect3 = new VertexEffectRotate( new Static1D(180), new Static3D(0,0,1), center1 );

    VertexEffectRotate  effect4 = new VertexEffectRotate( angle, axis1, center1 );

    VertexEffectRotate  effect5 = new VertexEffectRotate( angle, axis2, center2 );

    VertexEffectRotate  effect6 = new VertexEffectRotate( angle, axis3, center2 );

    VertexEffectDeform  effect7 = new VertexEffectDeform(dVec0, dRad, dCen0, dReg);

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

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

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

    VertexEffectSink effect11= new VertexEffectSink(sink,center, sReg);

    effect3.setMeshAssociation(14,-1);  // apply to mesh[1], [2] and [3]

    effect4.setMeshAssociation( 2,-1);  // apply only to mesh[1]

    effect5.setMeshAssociation( 4,-1);  // apply only to mesh[2]

    effect6.setMeshAssociation( 8,-1);  // apply only to mesh[3]

    result.apply(effect1);

    result.apply(effect2);

    result.apply(effect3);

    result.apply(effect4);

    result.apply(effect5);

    result.apply(effect6);

    result.apply(effect7);

    result.apply(effect8);

    result.apply(effect9);

    result.apply(effect10);

    result.apply(effect11);

    if( mRotArray[cubit]>=0 )

      {

      result.apply( ROTATION[mRotArray[cubit]] );

      }

    result.mergeEffComponents();

    return result;

    }

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

  MeshBase createCubitMesh(int cubit)

    {

    int kind = mRotArray[cubit];

    if( kind>=0 )

      {

      if( mMeshRotated[kind]==null ) mMeshRotated[kind] = createStaticMesh(cubit);

      return mMeshRotated[kind].copy(true);

      }

    else

      {

      if( mMesh==null ) mMesh = createStaticMesh(cubit);

      return mMesh.copy(true);

      }

    }

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

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

    {

    float STROKE = 0.044f*side;

    float OFF = STROKE/2 -1;

    float OFF2 = 0.5f*side + OFF;

    float HEIGHT = side - OFF;

    float RADIUS = side/12.0f;

    float ARC1_H = 0.2f*side;

    float ARC1_W = side*0.5f;

    float ARC2_W = 0.153f*side;

    float ARC2_H = 0.905f*side;

    float ARC3_W = side-ARC2_W;

    float M = SQ3/2;

    float D = (M/2 - 0.51f)*side;

    paint.setAntiAlias(true);

    paint.setStrokeWidth(STROKE);

    paint.setColor(FACE_COLORS[face]);

    paint.setStyle(Paint.Style.FILL);

    canvas.drawRect(left,top,left+side,top+side,paint);

    paint.setColor(INTERIOR_COLOR);

    paint.setStyle(Paint.Style.STROKE);

    canvas.drawLine(           left, M*HEIGHT+D,  side       +left, M*HEIGHT+D, paint);

    canvas.drawLine(      OFF +left, M*side  +D,       OFF2  +left,          D, paint);

    canvas.drawLine((side-OFF)+left, M*side  +D, (side-OFF2) +left,          D, paint);

    canvas.drawArc( ARC1_W-RADIUS+left, M*(ARC1_H-RADIUS)+D, ARC1_W+RADIUS+left, M*(ARC1_H+RADIUS)+D, 225, 90, false, paint);

    canvas.drawArc( ARC2_W-RADIUS+left, M*(ARC2_H-RADIUS)+D, ARC2_W+RADIUS+left, M*(ARC2_H+RADIUS)+D, 105, 90, false, paint);

    canvas.drawArc( ARC3_W-RADIUS+left, M*(ARC2_H-RADIUS)+D, ARC3_W+RADIUS+left, M*(ARC2_H+RADIUS)+D, 345, 90, false, paint);

    }

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

// I don't quite understand it, but 0.82 works better than the theoretically correct SQ3/2 ( 0.866 )

  float returnMultiplier()

    {

    return getSize()/0.82f;//(SQ3/2);

    }

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

  float[] getRowChances()

    {

    int size = getSize();

    int total = size*(size+1)/2;

    float running=0.0f;

    float[] chances = new float[size];

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

      {

      running += (size-i);

      chances[i] = running / total;

      }

    return chances;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int getBasicAngle()

    {

    return 3;

    }

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

// 0.82?? see returnMultiplier()

  public int computeRowFromOffset(float offset)

    {

    return (int)(getSize()*offset/0.82f);

    }

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

  public float returnRotationFactor(float offset)

    {

    int size = getSize();

    int row  = (int)(size*offset/(SQ3/2));

    return ((float)size)/(size-row);

    }

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

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

      }

    }

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

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

      }

    }

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

// TODO  (only needed for solvers - there are no Pyraminx solvers ATM)

  public String retObjectString()

    {

    return "";

    }

}