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

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

import android.graphics.Paint;

import org.distorted.library.effect.VertexEffectMove;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.type.Static4D;

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

public class RubikPyraminx extends RubikObject

{

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

         {

           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 )

         };

         {

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

           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 static MeshBase mMesh =null;

  static

    {

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

    Static1D angle  = new Static1D(180.0f);

    }

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

    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;

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

      {

      added += (i-1);

      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 )

      {

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

      }

    else

      {

      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)

    {

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

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

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

  int getNumFaces()

    {

    return FACE_COLORS.length;

    }

  int getNumStickerTypes()

    {

    return 1;

    }

  int getNumCubitFaces()

    {

    return FACE_COLORS.length;

    }

  float getScreenRatio()

    {

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

    {

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

    return belongs ? cubitface : NUM_FACES;

    }

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

    final int MESHES=4;

    float[] bands;

    int extraI, extraV;

      {

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

                      extraV = 2;

                      break;

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

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

                                     0.50f, 0.035f,

                                     0.0f, 0.040f };

                      extraV = 2;

                      break;

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

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

                                     0.50f, 0.035f,

                                     0.0f, 0.040f };

                      extraV = 1;

                      break;

      }

      {

      association <<= 1;

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

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

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

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

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

    result.apply(effect9);

    result.apply(effect10);

    if( mRotArray[cubit]>=0 )

      {

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

      }

    int kind = mRotArray[cubit];

    if( kind>=0 )

      {

    else

      {

    }

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

    {

    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 D = (M/2 - 0.51f)*side;

    paint.setStrokeWidth(STROKE);

    paint.setColor(FACE_COLORS[face]);

    paint.setStyle(Paint.Style.FILL);

    canvas.drawRect(left,top,left+side,top+side,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( 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

    {

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

    {

    return 3;

    }

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

    int size = getSize();

    }

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

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

    }

      {

      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;

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

      }