Magic Cube

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

// Copyright 2020 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;

import org.distorted.main.R;

import java.util.Random;

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

public class TwistyIvy extends TwistyObject

{

  public static final float IVY_D = 0.003f;

  public static final float IVY_C = 0.59f;

  public static final float IVY_M = 0.35f;

  private static final int IVY_N = 8;

  private static final int FACES_PER_CUBIT =6;

  // the four rotation axis of a RubikIvy. Must be normalized.

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(+SQ3/3,+SQ3/3,+SQ3/3),

           new Static3D(+SQ3/3,+SQ3/3,-SQ3/3),

           new Static3D(+SQ3/3,-SQ3/3,+SQ3/3),

           new Static3D(+SQ3/3,-SQ3/3,-SQ3/3)

         };

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

         {

           COLOR_YELLOW, COLOR_WHITE,

           COLOR_BLUE  , COLOR_GREEN,

           COLOR_RED   , COLOR_ORANGE

         };

  // All legal rotation quats of a RubikIvy

  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(  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 int[][] mFaceMap =

         {

           {  4, 2, 0, 12,12,12 },

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

           {  4, 3, 1, 12,12,12 },

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

           {  6, 12,12,12,12,12 },

           {  7, 12,12,12,12,12 },

           {  8, 12,12,12,12,12 },

           {  9, 12,12,12,12,12 },

           { 10, 12,12,12,12,12 },

           { 11, 12,12,12,12,12 },

         };

  private static MeshBase mCornerMesh, mFaceMesh;

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

  TwistyIvy(int size, Static4D quat, DistortedTexture texture,

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

    {

    super(size, size, quat, texture, mesh, effects, moves, ObjectList.IVY, res, scrWidth);

    }

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

  float getScreenRatio()

    {

    return 1.0f;

    }

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

  Static4D[] getQuats()

    {

    return QUATS;

    }

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

  int getNumFaces()

    {

    return FACE_COLORS.length;

    }

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

  boolean shouldResetTextureMaps()

    {

    return false;

    }

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

  int getNumStickerTypes(int numLayers)

    {

    return 2;

    }

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

  float[] getCuts(int numLayers)

    {

    float[] cuts = new float[1];

    cuts[0] = 0.0f;

    return cuts;

    }

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

  int getNumCubitFaces()

    {

    return FACES_PER_CUBIT;

    }

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

  float[][] getCubitPositions(int numLayers)

    {

    final float DIST_CORNER = (numLayers-1)*0.50f;

    final float DIST_CENTER = (numLayers-1)*0.50f;

    final float[][] CENTERS = new float[10][];

    CENTERS[0] = new float[] { DIST_CORNER, DIST_CORNER, DIST_CORNER };

    CENTERS[1] = new float[] {-DIST_CORNER, DIST_CORNER,-DIST_CORNER };

    CENTERS[2] = new float[] {-DIST_CORNER,-DIST_CORNER, DIST_CORNER };

    CENTERS[3] = new float[] { DIST_CORNER,-DIST_CORNER,-DIST_CORNER };

    CENTERS[4] = new float[] { DIST_CENTER,           0,           0 };

    CENTERS[5] = new float[] {-DIST_CENTER,           0,           0 };

    CENTERS[6] = new float[] {           0, DIST_CENTER,           0 };

    CENTERS[7] = new float[] {           0,-DIST_CENTER,           0 };

    CENTERS[8] = new float[] {           0,           0, DIST_CENTER };

    CENTERS[9] = new float[] {           0,           0,-DIST_CENTER };

    return CENTERS;

    }

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

  private int getQuat(int cubit)

    {

    switch(cubit)

      {

      case  0: return 0;

      case  1: return 2;

      case  2: return 3;

      case  3: return 1;

      case  4: return 8;

      case  5: return 11;

      case  6: return 10;

      case  7: return 9;

      case  8: return 0;

      case  9: return 2;

      }

    return 0;

    }

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

  MeshBase createFacesIvyCorner()

    {

    MeshBase[] meshes = new MeshBase[6];

    final float angle = (float)Math.PI/(2*IVY_N);

    final float CORR  = 1.0f - 2*IVY_D;

    final float DIST  = -0.5f*CORR + IVY_D;

    float[] vertices  = new float[2*(IVY_N+1)+6];

    vertices[0] = (0.5f-IVY_M) * IVY_C;

    vertices[1] = (DIST-IVY_M) * IVY_C;

    vertices[2] = (0.5f-IVY_M) * IVY_C;

    vertices[3] = (0.5f-IVY_M) * IVY_C;

    vertices[4] = (DIST-IVY_M) * IVY_C;

    vertices[5] = (0.5f-IVY_M) * IVY_C;

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

      {

      float ang = (IVY_N-i)*angle;

      float sin = (float)Math.sin(ang);

      float cos = (float)Math.cos(ang);

      vertices[2*i+6] = (CORR*(cos-0.5f)-IVY_M)*IVY_C;

      vertices[2*i+7] = (CORR*(sin-0.5f)-IVY_M)*IVY_C;

      }

    FactoryCubit factory = FactoryCubit.getInstance();

    float[] bands0 = factory.computeBands(+0.012f,20,0.2f,0.5f,7);

    float[] bands1 = factory.computeBands(-0.100f,20,0.2f,0.0f,2);

    meshes[0] = new MeshPolygon(vertices,bands0,1,2);

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

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

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

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

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

    meshes[3] = new MeshPolygon(vertices,bands1,1,2);

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

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

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

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

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

    return new MeshJoined(meshes);

    }

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

  private VertexEffect[] createVertexEffectsIvyCorner()

    {

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

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

    Static1D angle1 = new Static1D(+90);

    Static1D angle2 = new Static1D(-90);

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

    Static3D move1  = new Static3D(IVY_M-0.5f,IVY_M-0.5f,0);

    VertexEffect[] effect = new VertexEffect[5];

    effect[0] = new VertexEffectScale(1/IVY_C);

    effect[1] = new VertexEffectMove(move1);

    effect[2] = new VertexEffectScale(new Static3D(1,1,-1));

    effect[3] = new VertexEffectRotate(angle1,axisX,center);

    effect[4] = new VertexEffectRotate(angle2,axisY,center);

    effect[2].setMeshAssociation(54,-1);  // meshes 1,2,4,5

    effect[3].setMeshAssociation(18,-1);  // meshes 1,4

    effect[4].setMeshAssociation(36,-1);  // meshes 2,5

    return effect;

    }

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

  private MeshBase createFacesIvyFace()

    {

    MeshBase[] meshes = new MeshBase[2];

    final float angle = (float)Math.PI/(2*IVY_N);

    final float CORR  = 1.0f - 2*IVY_D;

    float[] vertices = new float[4*IVY_N];

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

      {

      float sin = (float)Math.sin(i*angle);

      float cos = (float)Math.cos(i*angle);

      vertices[2*i          ] = CORR*(0.5f-cos);

      vertices[2*i+1        ] = CORR*(0.5f-sin);

      vertices[2*i  +2*IVY_N] = CORR*(cos-0.5f);

      vertices[2*i+1+2*IVY_N] = CORR*(sin-0.5f);

      }

    FactoryCubit factory = FactoryCubit.getInstance();

    float[] bands0 = factory.computeBands(+0.03f,35,0.5f,0.5f,5);

    float[] bands1 = factory.computeBands(-0.10f,45,0.5f,0.0f,2);

    meshes[0] = new MeshPolygon(vertices,bands0,0,0);

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

    meshes[1] = new MeshPolygon(vertices,bands1,0,0);

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

    return new MeshJoined(meshes);

    }

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

  private MeshBase createIvyFaceMesh()

    {

    MeshBase mesh = createFacesIvyFace();

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

    Static3D[] vertices = new Static3D[2];

    vertices[0] = new Static3D(-0.5f,+0.5f,+0.0f);

    vertices[1] = new Static3D(+0.5f,-0.5f,+0.0f);

    FactoryCubit.getInstance().roundCorners(mesh,center,vertices,0.03f,0.10f);

    mesh.mergeEffComponents();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    mesh.addEmptyTexComponent();

    return mesh;

    }

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

  private MeshBase createIvyCornerMesh()

    {

    MeshBase mesh = createFacesIvyCorner();

    VertexEffect[] effects = createVertexEffectsIvyCorner();

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

    Static3D center = new Static3D(-0.5f,-0.5f,-0.5f);

    Static3D[] vertices = new Static3D[4];

    vertices[0] = new Static3D(+0.0f,+0.0f,+0.0f);

    vertices[1] = new Static3D(-1.0f,+0.0f,+0.0f);

    vertices[2] = new Static3D(+0.0f,-1.0f,+0.0f);

    vertices[3] = new Static3D(+0.0f,+0.0f,-1.0f);

    FactoryCubit.getInstance().roundCorners(mesh,center,vertices,0.03f,0.10f);

    mesh.mergeEffComponents();

    return mesh;

    }

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

  MeshBase createCubitMesh(int cubit, int numLayers)

    {

    MeshBase mesh;

    if( cubit<4 )

      {

      if( mCornerMesh==null ) mCornerMesh = createIvyCornerMesh();

      mesh = mCornerMesh.copy(true);

      }

    else

      {

      if( mFaceMesh==null ) mFaceMesh = createIvyFaceMesh();

      mesh = mFaceMesh.copy(true);

      }

    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( QUATS[getQuat(cubit)], new Static3D(0,0,0) );

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

    return mesh;

    }

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

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

    {

    return mFaceMap[cubit][cubitface];

    }

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

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

    {

    int COLORS = FACE_COLORS.length;

    FactorySticker factory = FactorySticker.getInstance();

    float S = 0.08f;

    float R = 0.12f;

    if( face<COLORS )

      {

      factory.drawIvyCornerSticker(canvas, paint, left, top, FACE_COLORS[face%COLORS], S, R);

      }

    else

      {

      factory.drawIvyCenterSticker(canvas, paint, left, top, FACE_COLORS[face%COLORS], S, R);

      }

    }

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

  float returnMultiplier()

    {

    return 2.0f;

    }

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

  float[] getRowChances(int numLayers)

    {

    float[] chances = new float[2];

    chances[0] = 0.5f;

    chances[1] = 1.0f;

    return chances;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int getBasicAngle()

    {

    return 3;

    }

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

  public void randomizeNewScramble(int[][] scramble, Random rnd, int num)

    {

    if( num==0 )

      {

      scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);

      }

    else

      {

      int newVector = rnd.nextInt(ROTATION_AXIS.length-1);

      scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);

      }

    float rowFloat = rnd.nextFloat();

    for(int row=0; row<mRowChances.length; row++)

      {

      if( rowFloat<=mRowChances[row] )

        {

        scramble[num][1] = row;

        break;

        }

      }

    switch( rnd.nextInt(2) )

      {

      case 0: scramble[num][2] = -1; break;

      case 1: scramble[num][2] =  1; break;

      }

    }

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

// The Ivy is solved if and only if:

//

// 1) all 4 of its corner cubits are rotated with the same quat

// 2) all its face cubits are rotated with the same quat like the corner ones,

//    and optionally they also might be upside down.

//

// i.e.

// cubits [4] and [5] - might be extra QUAT[1]

// cubits [6] and [7] - might be extra QUAT[2]

// cubits [8] and [9] - might be extra QUAT[3]

  public boolean isSolved()

    {

    int q1,q = CUBITS[0].mQuatIndex;

    if( CUBITS[1].mQuatIndex == q &&

        CUBITS[2].mQuatIndex == q &&

        CUBITS[3].mQuatIndex == q  )

      {

      q1 = mulQuat(q,1);

      if( CUBITS[4].mQuatIndex != q && CUBITS[4].mQuatIndex != q1 ) return false;

      if( CUBITS[5].mQuatIndex != q && CUBITS[5].mQuatIndex != q1 ) return false;

      q1 = mulQuat(q,2);

      if( CUBITS[6].mQuatIndex != q && CUBITS[6].mQuatIndex != q1 ) return false;

      if( CUBITS[7].mQuatIndex != q && CUBITS[7].mQuatIndex != q1 ) return false;

      q1 = mulQuat(q,3);

      if( CUBITS[8].mQuatIndex != q && CUBITS[8].mQuatIndex != q1 ) return false;

      if( CUBITS[9].mQuatIndex != q && CUBITS[9].mQuatIndex != q1 ) return false;

      return true;

      }

    return false;

    }

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

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

  public String retObjectString()

    {

    return "";

    }

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

  public int getObjectName(int numLayers)

    {

    return R.string.ivy2;

    }

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

  public int getInventor(int numLayers)

    {

    return R.string.ivy2_inventor;

    }

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

  public int getComplexity(int numLayers)

    {

    return 1;

    }

}