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

import org.distorted.helpers.ObjectSticker;

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.R;

import java.util.Random;

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

public class TwistyIvy extends TwistyObject

{

  public static final float IVY_D = 0.003f;

  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[] BASIC_ANGLE = new int[] { 3,3,3,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, 0, 2, 12,12,12 },

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

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

           {  5, 0, 3, 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;

  private static final ObjectSticker[] mStickers;

  private static final float[][] STICKERS = new float[][]

          {

             { 0.29258922f, -0.5f, 0.29258922f, 0.29258922f, -0.5f, 0.29258922f },

             { -0.5f, 0.5f, 0.5f, -0.5f }

          };

  private static final int NUM_STICKERS = STICKERS.length;

  static

    {

    mStickers = new ObjectSticker[NUM_STICKERS];

    float D = (float)(Math.PI/4);

    final float[][] angles = { { 0,0,D },{ D,D } };

    final float[][] radii  = { { 0,0.02f,0 },{ 0.06f,0.06f } };

    final float[] strokes = { 0.03f, 0.08f };

    for(int s=0; s<NUM_STICKERS; s++)

      {

      mStickers[s] = new ObjectSticker(STICKERS[s], angles[s],radii[s],strokes[s]);

      }

    }

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

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

    }

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

  float[][] getCuts(int numLayers)

    {

    float[] cut = new float[] {0.0f};

    return new float[][] { cut,cut,cut,cut };

    }

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

  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 createCubitMesh(int cubit, int numLayers)

    {

    MeshBase mesh;

    if( cubit<4 )

      {

      if( mCornerMesh==null )

        {

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

        final float CORR  = 1.0f - 2*IVY_D;

        float[][] centers= new float[][] { {-0.5f,-0.5f,-0.5f} };

        float[][] corners= new float[][] { {0.03f,0.10f}, {0.02f,0.10f} };

        int[] cornerIndexes= new int[3*(IVY_N+1)+4];

        int[] centerIndexes= new int[3*(IVY_N+1)+4];

        double[][] vertices= new double[3*(IVY_N+1)+4][3];

        int[][] vertIndexes= new int[6][IVY_N+4];

        int[] bandIndexes= new int[] { 0,0,0,1,1,1 };

        float[][] bands =

          {

               {+0.015f,20,0.2f,0.5f,7,1,2},

               {-0.100f,20,0.2f,0.0f,2,1,2}

          };

        for(int i=0; i<3*(IVY_N+1); i++)

          {

          cornerIndexes[i+4] = -1;

          centerIndexes[i+4] = -1;

          }

        cornerIndexes[0] = 1;

        cornerIndexes[1] = 0;

        cornerIndexes[2] = 0;

        cornerIndexes[3] = 0;

        centerIndexes[0] = 0;

        centerIndexes[1] = 0;

        centerIndexes[2] = 0;

        centerIndexes[3] = 0;

        vertices[0][0] = 0.0;

        vertices[0][1] = 0.0;

        vertices[0][2] = 0.0;

        vertices[1][0] =-1.0;

        vertices[1][1] = 0.0;

        vertices[1][2] = 0.0;

        vertices[2][0] = 0.0;

        vertices[2][1] =-1.0;

        vertices[2][2] = 0.0;

        vertices[3][0] = 0.0;

        vertices[3][1] = 0.0;

        vertices[3][2] =-1.0;

        vertIndexes[0][0] = 2;

        vertIndexes[0][1] = 0;

        vertIndexes[0][2] = 1;

        vertIndexes[3][0] = 2;

        vertIndexes[3][1] = 0;

        vertIndexes[3][2] = 1;

        vertIndexes[1][0] = 3;

        vertIndexes[1][1] = 0;

        vertIndexes[1][2] = 2;

        vertIndexes[4][0] = 3;

        vertIndexes[4][1] = 0;

        vertIndexes[4][2] = 2;

        vertIndexes[2][0] = 1;

        vertIndexes[2][1] = 0;

        vertIndexes[2][2] = 3;

        vertIndexes[5][0] = 1;

        vertIndexes[5][1] = 0;

        vertIndexes[5][2] = 3;

        int N1 = 4;

        int N2 = N1 + IVY_N + 1;

        int N3 = N2 + IVY_N + 1;

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

          {

          double cos1 = Math.cos((IVY_N-i)*angle);

          double sin1 = Math.sin((IVY_N-i)*angle);

          double cos2 = Math.cos((      i)*angle);

          double sin2 = Math.sin((      i)*angle);

          vertices[N1+i][0] = CORR*(cos1-0.5) - 0.5;

          vertices[N1+i][1] = CORR*(sin1-0.5) - 0.5;

          vertices[N1+i][2] = 0.0;

          vertices[N2+i][0] = 0.0;

          vertices[N2+i][1] = CORR*(sin2-0.5) - 0.5;

          vertices[N2+i][2] = CORR*(cos2-0.5) - 0.5;

          vertices[N3+i][0] = CORR*(cos2-0.5) - 0.5;

          vertices[N3+i][1] = 0.0;

          vertices[N3+i][2] = CORR*(sin2-0.5) - 0.5;

          vertIndexes[0][i+3] = N1 + i;

          vertIndexes[1][i+3] = N2 + i;

          vertIndexes[2][i+3] = N3 + i;

          vertIndexes[3][i+3] = N1 + i;

          vertIndexes[4][i+3] = N2 + i;

          vertIndexes[5][i+3] = N3 + i;

          }

        float C = 0.5f - SQ2/4;

        float[] convexCenter = new float[] {-C,-C,-C};

        FactoryCubit factory = FactoryCubit.getInstance();

        factory.createNewFaceTransform(vertices,vertIndexes);

        mCornerMesh = factory.createRoundedSolid(vertices, vertIndexes,

                                                 bands, bandIndexes,

                                                 corners, cornerIndexes,

                                                 centers, centerIndexes,

                                                 getNumCubitFaces(), convexCenter );

        }

      mesh = mCornerMesh.copy(true);

      }

    else

      {

      if( mFaceMesh==null )

        {

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

        final float CORR  = 1.0f - 2*IVY_D;

        double[][] vertices = new double[2*IVY_N][3];

        int[][] vert_indices = new int[2][2*IVY_N];

        int[] bandIndexes= new int[] { 0,1 };

        int[] indexes    = new int[2*IVY_N];

        float[][] corners= new float[][] { {0.03f,0.10f} };

        float[][] centers= new float[][] { {-0.0f,-0.0f,-0.5f} };

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

          {

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

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

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

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

          vertices[i      ][2] = 0;

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

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

          vertices[i+IVY_N][2] = 0;

          }

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

          {

          vert_indices[0][i] = i;

          vert_indices[1][i] = 2*IVY_N-1-i;

          }

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

          {

          indexes[i] = -1;

          }

        indexes[0] = indexes[IVY_N] = 0;

        float[][] bands =

          {

               {+0.03f,35,0.5f,0.5f,5,0,0},

               {+0.10f,45,0.5f,0.0f,2,0,0}

          };

        FactoryCubit factory = FactoryCubit.getInstance();

        factory.createNewFaceTransform(vertices,vert_indices);

        mFaceMesh = factory.createRoundedSolid(vertices, vert_indices,

                                                bands, bandIndexes,

                                                corners, indexes,

                                                centers, indexes,

                                                getNumCubitFaces(), null );

        }

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

    }

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

  int getColor(int face)

    {

    return FACE_COLORS[face];

    }

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

  ObjectSticker retSticker(int face)

    {

    return mStickers[face/NUM_FACES];

    }

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

  float returnMultiplier()

    {

    return 2.0f;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[] getBasicAngle()

    {

    return BASIC_ANGLE;

    }

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

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

    {

    if( curr==0 )

      {

      scramble[curr][0] = rnd.nextInt(NUM_AXIS);

      }

    else

      {

      int newVector = rnd.nextInt(NUM_AXIS -1);

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

      }

    scramble[curr][1] = rnd.nextFloat()<=0.5f ? 0 : 1;

    switch( rnd.nextInt(2) )

      {

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

      case 1: scramble[curr][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;

    }

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

  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;

    }

}