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

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 TwistyRex extends TwistyObject

{

  private static final int FACES_PER_CUBIT =6;

  public static final float REX_D = 0.2f;

  // the four rotation axis of a RubikRex. 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 RubikRex

  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 =

         {

           {  0, 18,18,18,18,18 },

           {  0, 18,18,18,18,18 },

           {  0, 18,18,18,18,18 },

           {  0, 18,18,18,18,18 },

           {  1, 18,18,18,18,18 },

           {  1, 18,18,18,18,18 },

           {  1, 18,18,18,18,18 },

           {  1, 18,18,18,18,18 },

           {  2, 18,18,18,18,18 },

           {  2, 18,18,18,18,18 },

           {  2, 18,18,18,18,18 },

           {  2, 18,18,18,18,18 },

           {  3, 18,18,18,18,18 },

           {  3, 18,18,18,18,18 },

           {  3, 18,18,18,18,18 },

           {  3, 18,18,18,18,18 },

           {  4, 18,18,18,18,18 },

           {  4, 18,18,18,18,18 },

           {  4, 18,18,18,18,18 },

           {  4, 18,18,18,18,18 },

           {  5, 18,18,18,18,18 },

           {  5, 18,18,18,18,18 },

           {  5, 18,18,18,18,18 },

           {  5, 18,18,18,18,18 },

           {  6, 18,18,18,18,18 },

           {  7, 18,18,18,18,18 },

           {  8, 18,18,18,18,18 },

           {  9, 18,18,18,18,18 },

           { 10, 18,18,18,18,18 },

           { 11, 18,18,18,18,18 },

           { 16,14, 18,18,18,18 },

           { 16,12, 18,18,18,18 },

           { 16,15, 18,18,18,18 },

           { 16,13, 18,18,18,18 },

           { 12,14, 18,18,18,18 },

           { 15,12, 18,18,18,18 },

           { 15,13, 18,18,18,18 },

           { 13,14, 18,18,18,18 },

           { 14,17, 18,18,18,18 },

           { 12,17, 18,18,18,18 },

           { 17,15, 18,18,18,18 },

           { 13,17, 18,18,18,18 },

         };

  private static final ObjectSticker[] mStickers;

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

          {

             { -0.5f, 0.1428f, -0.1428f, 0.5f, 0.35f, -0.35f },

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

             { -0.525f, 0.105f, 0.525f, 0.105f, 0.000f, -0.210f  }

          };

  private static final int NUM_STICKERS = STICKERS.length;

  static

    {

    mStickers = new ObjectSticker[NUM_STICKERS];

    final float F = (float)(Math.PI/20);

    final float R1= 0.02f;

    final float R2= 0.09f;

    final float R3= 0.06f;

    final float[][] angles = { { -F/2,F,F },null,{ F/10,-F,-F } };

    final float[][] radii  = { {R1,R1,R1},{R2,R2,R2,R2},{0,0,R3} };

    final float[] strokes = { 0.06f, 0.07f, 0.05f };

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

      {

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

      }

    }

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

  TwistyRex(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.REX, res, scrWidth);

    }

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

  float getScreenRatio()

    {

    return 1.5f;

    }

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

  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 C = SQ3*0.15f; // bit less than 1/6 of the length of the main diagonal

    float[] cut = new float[] {-C,+C};

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

    }

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

  int getNumCubitFaces()

    {

    return FACES_PER_CUBIT;

    }

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

  float[][] getCubitPositions(int numLayers)

    {

    final float DIST1= 0.50f;

    final float DIST2= (1+2*REX_D)/6;

    final float DIST3= 0.51f;

    final float[][] CENTERS = new float[24+6+12][];

    CENTERS[ 0] = new float[] { +DIST3, +DIST2, +DIST2};

    CENTERS[ 1] = new float[] { +DIST3, +DIST2, -DIST2};

    CENTERS[ 2] = new float[] { +DIST3, -DIST2, -DIST2};

    CENTERS[ 3] = new float[] { +DIST3, -DIST2, +DIST2};

    CENTERS[ 4] = new float[] { -DIST3, +DIST2, +DIST2};

    CENTERS[ 5] = new float[] { -DIST3, +DIST2, -DIST2};

    CENTERS[ 6] = new float[] { -DIST3, -DIST2, -DIST2};

    CENTERS[ 7] = new float[] { -DIST3, -DIST2, +DIST2};

    CENTERS[ 8] = new float[] { +DIST2, +DIST3, +DIST2};

    CENTERS[ 9] = new float[] { +DIST2, +DIST3, -DIST2};

    CENTERS[10] = new float[] { -DIST2, +DIST3, -DIST2};

    CENTERS[11] = new float[] { -DIST2, +DIST3, +DIST2};

    CENTERS[12] = new float[] { +DIST2, -DIST3, +DIST2};

    CENTERS[13] = new float[] { +DIST2, -DIST3, -DIST2};

    CENTERS[14] = new float[] { -DIST2, -DIST3, -DIST2};

    CENTERS[15] = new float[] { -DIST2, -DIST3, +DIST2};

    CENTERS[16] = new float[] { +DIST2, +DIST2, +DIST3};

    CENTERS[17] = new float[] { +DIST2, -DIST2, +DIST3};

    CENTERS[18] = new float[] { -DIST2, -DIST2, +DIST3};

    CENTERS[19] = new float[] { -DIST2, +DIST2, +DIST3};

    CENTERS[20] = new float[] { +DIST2, +DIST2, -DIST3};

    CENTERS[21] = new float[] { +DIST2, -DIST2, -DIST3};

    CENTERS[22] = new float[] { -DIST2, -DIST2, -DIST3};

    CENTERS[23] = new float[] { -DIST2, +DIST2, -DIST3};

    CENTERS[24] = new float[] { +DIST3, +0.00f, +0.00f};

    CENTERS[25] = new float[] { -DIST3, +0.00f, +0.00f};

    CENTERS[26] = new float[] { +0.00f, +DIST3, +0.00f};

    CENTERS[27] = new float[] { +0.00f, -DIST3, +0.00f};

    CENTERS[28] = new float[] { +0.00f, +0.00f, +DIST3};

    CENTERS[29] = new float[] { +0.00f, +0.00f, -DIST3};

    CENTERS[30] = new float[] { +0.00f, +DIST1, +DIST1};

    CENTERS[31] = new float[] { +DIST1, +0.00f, +DIST1};

    CENTERS[32] = new float[] { +0.00f, -DIST1, +DIST1};

    CENTERS[33] = new float[] { -DIST1, +0.00f, +DIST1};

    CENTERS[34] = new float[] { +DIST1, +DIST1, +0.00f};

    CENTERS[35] = new float[] { +DIST1, -DIST1, +0.00f};

    CENTERS[36] = new float[] { -DIST1, -DIST1, +0.00f};

    CENTERS[37] = new float[] { -DIST1, +DIST1, +0.00f};

    CENTERS[38] = new float[] { +0.00f, +DIST1, -DIST1};

    CENTERS[39] = new float[] { +DIST1, +0.00f, -DIST1};

    CENTERS[40] = new float[] { +0.00f, -DIST1, -DIST1};

    CENTERS[41] = new float[] { -DIST1, +0.00f, -DIST1};

    return CENTERS;

    }

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

  ObjectShape getObjectShape(int cubit, int numLayers)

    {

    int variant = getCubitVariant(cubit,numLayers);

    if( variant==0 )

      {

      float G = (1-REX_D)*SQ2/2;

      double[][] vertices =

         {

             {  -0.033333f, 0.23333f, 0.0f },

             {  -0.233333f, 0.03333f, 0.0f },

             {  +0.216666f,-0.23666f, 0.0f },

             {  +0.236666f,-0.21666f, 0.0f }

         };

      int[][] vertIndexes = { {0,1,2,3},{3,2,1,0} };

      float[][] centers= new float[][] { {0.0f,0.0f,-G/3} };

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

      int[] indices= {-1,-1,0,0};

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

      float[][] bands =

        {

            {+0.016f,10,G/3,0.5f,5,1,1},

            {+0.230f,45,G/3,0.0f,2,0,0}

        };

      return new ObjectShape(vertices,vertIndexes,bands,bandIndices,corners,indices,centers,indices,getNumCubitFaces(), null);

      }

    else if( variant==1 )

      {

      double[][] vertices =

        {

            { -REX_D,   0.0f, 0.0f },

            {   0.0f, -REX_D, 0.0f },

            { +REX_D,   0.0f, 0.0f },

            {   0.0f, +REX_D, 0.0f }

        };

      int[][] vertIndexes= { {0,1,2,3},{3,2,1,0} };

      int[] indices= {-1,-1,-1,-1};

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

      float[][] bands =

        {

            {0.025f,10,REX_D/2,0.5f,5,0,0},

            {0.000f,45,REX_D/2,0.0f,2,0,0}

        };

      return new ObjectShape(vertices,vertIndexes,bands,bandIndices,null,indices,null,indices,getNumCubitFaces(), null);

      }

    else

      {

      float E = 0.5f - REX_D;

      float F = 0.5f;

      float G = (float)Math.sqrt(E*E+F*F);

      double[][] vertices =

         {

             { -F, 0, 0 },

             {  0,-E, 0 },

             { +F, 0, 0 },

             {  0, 0,-E },

         };

      int[][] vertIndexes = { {0,1,2}, {0,2,3}, {0,3,1}, {1,3,2} };

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

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

      int[] indices= {0,-1,0,-1};

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

      float[][] bands =

        {

           {0.03f,27,F/3,0.8f,5,2,3},

           {0.01f,45,G/3,0.2f,3,1,2}

        };

      return new ObjectShape(vertices,vertIndexes,bands,bandIndices,corners,indices,centers,indices,getNumCubitFaces(), null);

      }

    }

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

  private Static4D getQuat(int cubit, int numLayers)

    {

    switch(cubit)

      {

      case  0: return new Static4D(+SQ2/2,     0,+SQ2/2,     0);

      case  1: return QUATS[5];

      case  2: return new Static4D(     0,-SQ2/2,     0, SQ2/2);

      case  3: return QUATS[8];

      case  4: return QUATS[6];

      case  5: return new Static4D(-SQ2/2,     0,+SQ2/2,     0);

      case  6: return QUATS[11];

      case  7: return new Static4D(     0,+SQ2/2,     0, SQ2/2);

      case  8: return new Static4D(+SQ2/2,     0,     0, SQ2/2);

      case  9: return QUATS[10];

      case 10: return new Static4D(     0,+SQ2/2,+SQ2/2,     0);

      case 11: return QUATS[4];

      case 12: return QUATS[9];

      case 13: return new Static4D(-SQ2/2,     0,     0, SQ2/2);

      case 14: return QUATS[7];

      case 15: return new Static4D(     0,-SQ2/2,+SQ2/2,     0);

      case 16: return new Static4D(     0,     0,-SQ2/2, SQ2/2);

      case 17: return QUATS[0];

      case 18: return new Static4D(     0,     0,+SQ2/2, SQ2/2);

      case 19: return QUATS[3];

      case 20: return QUATS[1];

      case 21: return new Static4D(+SQ2/2,-SQ2/2,     0,     0);

      case 22: return QUATS[2];

      case 23: return new Static4D(+SQ2/2,+SQ2/2,     0,     0);

      case 24: return new Static4D(     0,-SQ2/2,     0, SQ2/2);

      case 25: return new Static4D(     0,+SQ2/2,     0, SQ2/2);

      case 26: return new Static4D(+SQ2/2,     0,     0, SQ2/2);

      case 27: return new Static4D(-SQ2/2,     0,     0, SQ2/2);

      case 28: return QUATS[0];

      case 29: return QUATS[1];

      case 30: return QUATS[0];

      case 31: return new Static4D(     0,     0,+SQ2/2, SQ2/2);

      case 32: return QUATS[3];

      case 33: return new Static4D(     0,     0,-SQ2/2, SQ2/2);

      case 34: return new Static4D(     0,-SQ2/2,     0, SQ2/2);

      case 35: return QUATS[7];

      case 36: return QUATS[9];

      case 37: return new Static4D(     0,+SQ2/2,     0, SQ2/2);

      case 38: return new Static4D(+SQ2/2,     0,     0, SQ2/2);

      case 39: return QUATS[8];

      case 40: return QUATS[1];

      case 41: return QUATS[6];

      }

    return QUATS[0];

    }

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

  private int getNumCubitVariants(int numLayers)

    {

    return 3;

    }

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

  int getCubitVariant(int cubit, int numLayers)

    {

    return cubit<24 ? 0 : (cubit<30?1:2);

    }

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

  MeshBase createCubitMesh(int cubit, int numLayers)

    {

    int variant = getCubitVariant(cubit,numLayers);

    if( mMeshes==null )

      {

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.clear();

      mMeshes = new MeshBase[getNumCubitVariants(numLayers)];

      }

    if( mMeshes[variant]==null )

      {

      ObjectShape shape = getObjectShape(cubit,numLayers);

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.createNewFaceTransform(shape);

      mMeshes[variant] = factory.createRoundedSolid(shape);

      }

    MeshBase mesh = mMeshes[variant].copy(true);

    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit,numLayers), 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 : 2;

    switch( rnd.nextInt(2) )

      {

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

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

      }

    }

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

// The Rex is solved if and only if:

//

// 1) all 12 of its edge cubits are rotated with the same quat

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

//    and optionally they also might be upside down.

//

// i.e.

// corners ( 0, 1, 2, 3, 4, 5, 6, 7) and faces (24,25) - might be extra QUAT[1]

// corners ( 8, 9,10,11,12,13,14,15) and faces (26,27) - might be extra QUAT[2]

// corners (16,17,18,19,20,21,22,23) and faces (28,29) - might be extra QUAT[3]

  public boolean isSolved()

    {

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

    for(int i=31; i<42; i++)

      {

      if( CUBITS[i].mQuatIndex != q) return false;

      }

    q1 = mulQuat(q,1);

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

      {

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

      }

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

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

    q1 = mulQuat(q,2);

    for(int i=8; i<16; i++)

      {

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

      }

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

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

    q1 = mulQuat(q,3);

    for(int i=16; i<24; i++)

      {

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

      }

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

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

    return true;

    }

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

  public int getObjectName(int numLayers)

    {

    return R.string.rex3;

    }

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

  public int getInventor(int numLayers)

    {

    return R.string.rex3_inventor;

    }

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

  public int getComplexity(int numLayers)

    {

    return 3;

    }

}