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

import org.distorted.helpers.ObjectSticker;

import org.distorted.helpers.ScrambleState;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedTexture;

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;

import static org.distorted.objects.TwistyMinx.MINX_DBLUE;

import static org.distorted.objects.TwistyMinx.MINX_DGREEN;

import static org.distorted.objects.TwistyMinx.MINX_DRED;

import static org.distorted.objects.TwistyMinx.MINX_DYELLOW;

import static org.distorted.objects.TwistyMinx.MINX_GREY;

import static org.distorted.objects.TwistyMinx.MINX_LBLUE;

import static org.distorted.objects.TwistyMinx.MINX_LGREEN;

import static org.distorted.objects.TwistyMinx.MINX_ORANGE;

import static org.distorted.objects.TwistyMinx.MINX_PINK;

import static org.distorted.objects.TwistyMinx.MINX_SANDY;

import static org.distorted.objects.TwistyMinx.MINX_VIOLET;

import static org.distorted.objects.TwistyMinx.MINX_WHITE;

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

class TwistyUltimate extends TwistyObject

{

  private static final float A = (float)Math.sqrt(21*SQ5+47);

  private static final float B = SQ6*(5*SQ5+11)/(6*A);

  private static final float C = SQ6*(  SQ5+ 2)/(3*A);

  private static final float D = SQ3/3;

  private static final float E = (SQ5+1)/4;

  private static final float F = (SQ5-1)/4;

  private static final float G = (SQ5+3)/4;

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D( B,0,C ),

           new Static3D( C,B,0 ),

           new Static3D(-D,D,D ),

           new Static3D( 0,C,-B)

         };

  private static final int[] BASIC_ANGLE = new int[] { 3,3,3,3 };

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

         {

           MINX_LGREEN, MINX_PINK   , MINX_SANDY , MINX_LBLUE,

           MINX_ORANGE, MINX_VIOLET , MINX_DGREEN, MINX_DRED ,

           MINX_DBLUE , MINX_DYELLOW, MINX_WHITE , MINX_GREY

         };

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

         {

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

           new Static4D(-0.5f, 0.5f, 0.5f, 0.5f ),

           new Static4D( 0.5f,-0.5f,-0.5f, 0.5f ),

           new Static4D( 0.0f,    F,   -E, 0.5f ),

           new Static4D( 0.0f,   -F,    E, 0.5f ),

           new Static4D(    E, 0.0f,    F, 0.5f ),

           new Static4D(   -E, 0.0f,   -F, 0.5f ),

           new Static4D(    F,    E, 0.0f, 0.5f ),

           new Static4D(   -F,   -E, 0.0f, 0.5f ),

           new Static4D(    E,    F,-0.5f, 0.0f ),

           new Static4D( 0.5f,   -E,    F, 0.0f ),

           new Static4D(    F, 0.5f,    E, 0.0f )

         };

  // Colors of the faces of cubits.

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

         {

           { 25,24,35, 36,36,36,36,36 },

           { 27,28,29, 36,36,36,36,36 },

           { 31,26,30, 36,36,36,36,36 },

           { 32,34,33, 36,36,36,36,36 },

           { 31,32,25, 36,36,36,36,36 },

           { 33,28,24, 36,36,36,36,36 },

           { 26,35,27, 36,36,36,36,36 },

           { 30,29,34, 36,36,36,36,36 },

           {  8, 0,13,21, 36,36,36,36 },

           {  1, 2,19,23, 36,36,36,36 },

           {  4,11,12,15, 36,36,36,36 },

           {  3, 6,14,17, 36,36,36,36 },

           {  5, 9,22,16, 36,36,36,36 },

           {  7,10,20,18, 36,36,36,36 }

         };

  // centers of the 14 cubits.

  static final float[][] CENTERS = new float[][]

         {

           { 0.0f,-0.5f,    G },

           {    E,   -E,   -E },

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

           { 0.5f,    G, 0.0f },

           {   -E,    E,    E },

           {    G, 0.0f, 0.5f },

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

           { 0.0f, 0.5f,   -G },

           {        E/2, (E+0.5f)/2,    (E+G)/2 },

           {   -(E+G)/2,       -E/2, (E+0.5f)/2 },

           { (E+0.5f)/2,   -(E+G)/2,        E/2 },

           {       -E/2,-(E+0.5f)/2,   -(E+G)/2 },

           {    (E+G)/2,        E/2,-(E+0.5f)/2 },

           {-(E+0.5f)/2,    (E+G)/2,       -E/2 }

         };

  private static final double[][] VERTICES_SMALL_LEFT = new double[][]

         {

            {         0.000,         0.000,         0.000},

            {       - 0.250,-SQ5/8 - 0.125,-SQ5/8 - 0.375},

            { SQ5/8 + 0.125,-SQ5/8 - 0.375,       + 0.250},

            { SQ5/8 + 0.375,       + 0.250,-SQ5/8 - 0.125},

            { SQ5/4 + 0.250,-SQ5/4 - 0.250,-SQ5/4 - 0.250},

            { SQ5/8 - 0.125,       + 0.250,-SQ5/8 - 0.125},

            {       - 0.250,-SQ5/8 - 0.125,-SQ5/8 + 0.125},

            { SQ5/8 + 0.125,-SQ5/8 + 0.125,       + 0.250}

         };

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

         {

           {6,0,5,1},   // counterclockwise!

           {0,7,3,5},

           {0,6,2,7},

           {1,5,3,4},

           {3,7,2,4},

           {2,6,1,4},

         };

  private static final double[][] VERTICES_SMALL_RIGHT = new double[][]

         {

           { 0.0       ,  0.0      , 0.0       },

           { -0.5*E    , 0.5*E+0.25, -0.25     },

           {-0.25      , -E/2      , (-2*E-1)/4},

           { 0.5*E+0.25, 0.25      , -E/2      },

           { 0.0       , 0.5       , -E-0.5    },

           { 0.0       , 0.5       , 0.0       },

           { -0.5*E    ,-0.5*E+0.25, -0.25     },

           {  0.5*E    ,-0.5*E+0.25, -0.25     }

         };

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

         {

           {6,0,5,1},   // counterclockwise!

           {0,7,3,5},

           {0,6,2,7},

           {4,3,5,1},

           {4,2,7,3},

           {4,1,6,2},

         };

  private static final double[][] VERTICES_BIG = new double[][]

         {

           {-E/2     ,-E/2+0.25,     0.25},

           { E/2     , E/2-0.25,    -0.25},

           {-E       ,     0.00,     0.00},

           {     0.25, E/2     ,-E/2-0.25},

           {-E/2     ,-E/2-0.25,     0.25},

           { E/2+0.25,    -0.25,-E/2     },

           {-E       ,    -0.50,     0.00},

           {     0.50,     0.00,-E       },

           {-E  +0.25, E/2     ,-E/2-0.25},

           {     0.25,-E/2-0.50,-E/2+0.25},

           {-E/2     ,-E/2-0.25,-E  -0.25}

         };

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

         {

           {0,1,3,8,2},   // counterclockwise!

           {0,4,9,5,1},

           { 0,2,6,4},

           { 1,5,7,3},

           {10,9,4,6},

           {10,9,5,7},

           {10,8,3,7},

           {10,8,2,6}

         };

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

         {

           0,6,1,2,0,4,6,5,0,1,4,9,5,2

         };

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

         {

           { -0.14400357f, -0.47894150f, 0.50000000f,-0.011045523f, 0.37700626f, 0.36749030f,-0.26699730f, 0.36749026f, -0.46600536f, -0.24499352f }, // Big cubit 1st

           {  0.36327127f,  0.26393202f,-0.36327127f, 0.500000000f,-0.36327127f,-0.26393202f, 0.36327127f,-0.50000000f },                             // Big cubit 2nd

           { -0.29389262f, -0.50000000f, 0.29389262f,-0.309017000f, 0.29389262f, 0.30901700f,-0.29389262f, 0.50000000f },                             // Small cubit 1st

         };

  private static final ObjectSticker[] mStickers;

  static

    {

    mStickers = new ObjectSticker[STICKERS.length];

    final float R1 = 0.08f;

    final float R2 = 0.13f;

    final float R3 = 0.11f;

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

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

    for(int s=0; s<STICKERS.length; s++)

      {

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

      }

    }

  private int mCurrState;

  private int mIndexExcluded;

  private final ScrambleState[] mStates;

  private int[][] mScrambleTable;

  private int[] mNumOccurences;

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

  TwistyUltimate(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.ULTI, res, scrWidth);

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

    mStates = new ScrambleState[]

      {

      new ScrambleState( new int[][] {tmp,tmp,tmp,tmp} )

      };

    }

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

  int[] getSolvedQuats(int cubit, int numLayers)

    {

    int status = retCubitSolvedStatus(cubit,numLayers);

    return status<0 ? null : buildSolvedQuats(MovementUltimate.FACE_AXIS[status],QUATS);

    }

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

  ObjectShape getObjectShape(int cubit, int numLayers)

    {

    int variant = getCubitVariant(cubit,numLayers);

    if( variant==0 )

      {

      float[][] bands     = new float[][] { {0.03f,17,0.5f,0.2f,5,2,2}, {0.01f, 1,0.5f,0.2f,5,2,2} };

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

      float[][] corners   = new float[][] {  { 0.013f, 0.08f } };

      int[] cornerIndices = new int[] { 0, 0, 0, 0,-1, 0, 0, 0 };

      float[][] centers   = new float[][] { { 0.0f,-0.5f, -(SQ5+3)/4 } };

      int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0 };

      return new ObjectShape(VERTICES_SMALL_RIGHT,VERT_INDEXES_SMALL_RIGHT,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);

      }

    else if( variant==1 )

      {

      float[][] bands     = new float[][] { {0.03f,17,0.5f,0.2f,5,2,2}, {0.01f, 1,0.5f,0.2f,5,2,2} };

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

      float[][] corners   = new float[][] {  { 0.013f, 0.08f } };

      int[] cornerIndices = new int[] { 0, 0, 0, 0,-1, 0, 0, 0 };

      float[][] centers   = new float[][] { { 0.0f,-0.5f, -(SQ5+3)/4 } };

      int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0 };

      return new ObjectShape(VERTICES_SMALL_LEFT,VERT_INDEXES_SMALL_LEFT,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);

      }

    else

      {

      float[][] bands     = new float[][] { {0.04f,17,0.5f,0.2f,5,2,2}, {0.03f,17,0.5f,0.2f,5,2,2}, {0.01f, 1,0.5f,0.2f,5,2,2} };

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

      float[][] corners   = new float[][] { { 0.013f, 0.08f } };

      int[] cornerIndices = new int[] { 0,0,0,0,0,0,0,0,0,0,-1 };

      float[][] centers   = new float[][] { { -(SQ5+1)/8, 0.25f, -(SQ5+5)/8 } };

      int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0,0,0,0 };

      return new ObjectShape(VERTICES_BIG,VERT_INDEXES_BIG,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);

      }

    }

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

  Static4D getQuat(int cubit, int numLayers)

    {

    return QUATS[QUAT_INDEX[cubit]];

    }

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

  int getNumCubitVariants(int numLayers)

    {

    return 3;

    }

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

  int getCubitVariant(int cubit, int numLayers)

    {

    return cubit<4 ? 0 : (cubit<8 ? 1:2);

    }

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

  float[][] getCubitPositions(int numLayers)

    {

    return CENTERS;

    }

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

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

    {

    return mFaceMap[cubit][cubitface];

    }

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

  int getColor(int face)

    {

    return FACE_COLORS[face];

    }

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

  ObjectSticker retSticker(int face)

    {

    return mStickers[face/NUM_FACES];

    }

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

  float returnMultiplier()

    {

    return 1.0f;

    }

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

  Static4D[] getQuats()

    {

    return QUATS;

    }

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

  int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  boolean shouldResetTextureMaps()

    {

    return false;

    }

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

  int getNumFaces()

    {

    return FACE_COLORS.length;

    }

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

  float[][] getCuts(int numLayers)

    {

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

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

    }

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

  int getNumStickerTypes(int numLayers)

    {

    return STICKERS.length;

    }

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

  int getNumCubitFaces()

    {

    return 8;

    }

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

  float getScreenRatio()

    {

    return 0.67f;

    }

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

  private void initializeScrambling()

    {

    int numLayers = getNumLayers();

    if( mScrambleTable ==null )

      {

      mScrambleTable = new int[NUM_AXIS][numLayers];

      }

    if( mNumOccurences ==null )

      {

      int max=0;

      for (ScrambleState mState : mStates)

        {

        int tmp = mState.getTotal(-1);

        if (max < tmp) max = tmp;

        }

      mNumOccurences = new int[max];

      }

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

      for(int j=0; j<numLayers; j++) mScrambleTable[i][j] = 0;

    }

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

// PUBLIC API

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

    {

    if( curr==0 )

      {

      mCurrState     = 0;

      mIndexExcluded =-1;

      initializeScrambling();

      }

    int[] info= mStates[mCurrState].getRandom(rnd, mIndexExcluded, mScrambleTable, mNumOccurences);

    scramble[curr][0] = info[0];

    scramble[curr][1] = info[1];

    scramble[curr][2] = info[2];

    mCurrState     = info[3];

    mIndexExcluded = info[0];

    }

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

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[] getBasicAngle()

    {

    return BASIC_ANGLE;

    }

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

  public int getObjectName(int numLayers)

    {

    return R.string.ulti2;

    }

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

  public int getInventor(int numLayers)

    {

    return R.string.ulti2_inventor;

    }

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

  public int getComplexity(int numLayers)

    {

    return 6;

    }

}