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 static org.distorted.objects.Movement.TYPE_NOT_SPLIT;

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;

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

public class TwistyDiamond extends Twisty8

{

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

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

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

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

           new Static3D(     0,-SQ3/3,-SQ6/3),

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

         };

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

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

      {

          {{1,2,3}},{{1,2,3}},{{0,2,3}},{{0,2,3}},{{0,1,3}},{{0,1,3}},{{0,1,2}},{{0,1,2}}

      };

  private ScrambleState[] mStates;

  private int[] mBasicAngle;

  private int[] mFaceMap;

  private float[][] mCuts;

  private boolean[][] mLayerRotatable;

  private Static4D[] mQuats;

  private int[] mTetraToFaceMap;

  private ObjectSticker[] mStickers;

  private Movement mMovement;

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

  TwistyDiamond(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.DIAM, res, scrWidth);

    }

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

  ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int size = getNumLayers();

      int[] tmp = new int[3*2*size];

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

        {

        tmp[3*i  ] = (i<size) ?  i:i-size;

        tmp[3*i+1] = (i%2==0) ? -1:1;

        tmp[3*i+2] = 0;

        }

      mStates = new ScrambleState[]

        {

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

        };

      }

    return mStates;

    }

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

  private void initializeQuats()

    {

    mQuats = new Static4D[]

         {

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

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

          new Static4D(+SQ2/2,  0.0f, -SQ2/2,  0.0f ),

          new Static4D(-SQ2/2,  0.0f, -SQ2/2,  0.0f ),

          new Static4D(+SQ2/2,  0.5f,   0.0f,  0.5f ),

          new Static4D(-SQ2/2,  0.5f,   0.0f,  0.5f ),

          new Static4D(  0.0f,  0.5f, +SQ2/2,  0.5f ),

          new Static4D(  0.0f,  0.5f, -SQ2/2,  0.5f ),

          new Static4D(+SQ2/2,  0.5f,   0.0f, -0.5f ),

          new Static4D(-SQ2/2,  0.5f,   0.0f, -0.5f ),

          new Static4D(  0.0f,  0.5f, +SQ2/2, -0.5f ),

          new Static4D(  0.0f,  0.5f, -SQ2/2, -0.5f )

         };

    }

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

  int[] getSolvedQuats(int cubit, int numLayers)

    {

    if( mQuats==null ) initializeQuats();

    if( mFaceMap==null ) mFaceMap = new int[] {4,0,6,2,7,3,5,1};

    int status = retCubitSolvedStatus(cubit,numLayers);

    return status<0 ? null : buildSolvedQuats(Movement8.FACE_AXIS[mFaceMap[status]],mQuats);

    }

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

  Static4D[] getQuats()

    {

    if( mQuats==null ) initializeQuats();

    return mQuats;

    }

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

  int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  int getNumStickerTypes(int numLayers)

    {

    return 1;

    }

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

  float[][] getCuts(int numLayers)

    {

    if( numLayers<2 ) return null;

    if( mCuts==null )

      {

      mCuts = new float[4][numLayers-1];

      float cut = (SQ6/6)*(2-numLayers);

      for(int i=0; i<numLayers-1; i++)

        {

        mCuts[0][i] = cut;

        mCuts[1][i] = cut;

        mCuts[2][i] = cut;

        mCuts[3][i] = cut;

        cut += SQ6/3;

        }

      }

    return mCuts;

    }

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

  private void getLayerRotatable(int numLayers)

    {

    if( mLayerRotatable==null )

      {

      int numAxis = ROT_AXIS.length;

      boolean[] tmp = new boolean[numLayers];

      for(int i=0; i<numLayers; i++) tmp[i] = true;

      mLayerRotatable = new boolean[numAxis][];

      for(int i=0; i<numAxis; i++) mLayerRotatable[i] = tmp;

      }

    }

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

  int getNumCubitFaces()

    {

    return 8;

    }

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

  private int getNumOctahedrons(int layers)

    {

    return layers==1 ? 1 : 4*(layers-1)*(layers-1) + 2;

    }

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

  private int getNumTetrahedrons(int layers)

    {

    return 4*layers*(layers-1);

    }

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

  private int createOctaPositions(float[][] centers, int index, int layers, float height)

    {

    float x = (layers-1)*0.5f;

    float z = (layers+1)*0.5f;

    for(int i=0; i<layers; i++, index++)

      {

      z -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-1; i++, index++)

      {

      x -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-1; i++, index++)

      {

      z += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    for(int i=0; i<layers-2; i++, index++)

      {

      x += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    return index;

    }

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

  private int createTetraPositions(float[][] centers, int index, int layers, float height)

    {

    float x = (layers-1)*0.5f;

    float z =  layers*0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      z -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x += 0.5f;

    z -= 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      x -= 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x -= 0.5f;

    z -= 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      z += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    x -= 0.5f;

    z += 0.5f;

    for(int i=0; i<layers-1; i++, index++)

      {

      x += 1;

      centers[index][0] = x;

      centers[index][1] = height;

      centers[index][2] = z;

      }

    return index;

    }

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

  float[][] getCubitPositions(int layers)

    {

    int numO = getNumOctahedrons(layers);

    int numT = getNumTetrahedrons(layers);

    int index = 0;

    float height = 0.0f;

    float[][] CENTERS = new float[numO+numT][3];

    index = createOctaPositions(CENTERS,index,layers,height);

    for(int i=layers-1; i>0; i--)

      {

      height += SQ2/2;

      index = createOctaPositions(CENTERS,index,i,+height);

      index = createOctaPositions(CENTERS,index,i,-height);

      }

    height = SQ2/4;

    for(int i=layers; i>1; i--)

      {

      index = createTetraPositions(CENTERS,index,i,+height);

      index = createTetraPositions(CENTERS,index,i,-height);

      height += SQ2/2;

      }

    return CENTERS;

    }

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

  private int retFaceTetraBelongsTo(int tetra, int numLayers)

    {

    if( mTetraToFaceMap==null ) mTetraToFaceMap = new int[] {1,2,3,0,5,6,7,4};

    for(int i=numLayers-1; i>0; i--)

      {

      if( tetra < 8*i ) return mTetraToFaceMap[tetra/i];

      tetra -= 8*i;

      }

    return -1;

    }

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

  ObjectShape getObjectShape(int cubit, int numLayers)

    {

    int variant = getCubitVariant(cubit,numLayers);

    int N = numLayers>3 ? 5:6;

    int E = numLayers>2 ? (numLayers>3 ? 0:1):2;

    if( variant==0 )

      {

      double[][] vertices = new double[][]

          {

             { 0.5,   0.0, 0.5},

             { 0.5,   0.0,-0.5},

             {-0.5,   0.0,-0.5},

             {-0.5,   0.0, 0.5},

             { 0.0, SQ2/2, 0.0},

             { 0.0,-SQ2/2, 0.0}

          };

      int[][] vert_indices = new int[][]

          {

             {3,0,4},

             {0,1,4},

             {1,2,4},

             {2,3,4},

             {5,0,3},

             {5,1,0},

             {5,2,1},

             {5,3,2}

          };

      float[][] bands     = new float[][] { {0.05f,35,0.5f,0.8f,N,E,E} };

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

      float[][] corners   = new float[][] { {0.04f,0.20f} };

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

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

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

      return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);

      }

    else

      {

      double[][] vertices = new double[][] { {-0.5, SQ2/4, 0.0}, { 0.5, SQ2/4, 0.0}, { 0.0,-SQ2/4, 0.5}, { 0.0,-SQ2/4,-0.5} };

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

      float[][] bands     = new float[][] { {0.05f,35,0.5f,0.8f,N,E,E} };

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

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

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

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

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

      return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);

      }

    }

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

  Static4D getQuat(int cubit, int numLayers)

    {

    if( mQuats==null ) initializeQuats();

    int numO = getNumOctahedrons(numLayers);

    if( cubit<numO ) return mQuats[0];

    switch( retFaceTetraBelongsTo(cubit-numO, numLayers) )

      {

      case 0: return mQuats[0];                         // unit quat

      case 1: return new Static4D(0,-SQ2/2,0,SQ2/2);    //  90 along Y

      case 2: return mQuats[1];                         // 180 along Y

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

      case 4: return new Static4D(0,     0,1,    0);    // 180 along Z

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

      case 6: return new Static4D(     1,0,0,    0);    // 180 along X

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

      }

    return null;

    }

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

  int getNumCubitVariants(int numLayers)

    {

    return 2;

    }

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

  int getCubitVariant(int cubit, int numLayers)

    {

    return cubit<getNumOctahedrons(numLayers) ? 0 : 1;

    }

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

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

    {

    int numO = getNumOctahedrons(size);

    if( cubit<numO )

      {

      int axis = 0;

      int layer= 1;

      switch(cubitface)

        {

        case 0: axis = 2; layer =             1; break;

        case 1: axis = 0; layer = (1<<(size-1)); break;

        case 2: axis = 3; layer =             1; break;

        case 3: axis = 1; layer = (1<<(size-1)); break;

        case 4: axis = 3; layer = (1<<(size-1)); break;

        case 5: axis = 1; layer =             1; break;

        case 6: axis = 2; layer = (1<<(size-1)); break;

        case 7: axis = 0; layer =             1; break;

        }

      return CUBITS[cubit].mRotationRow[axis] == layer ? cubitface : NUM_TEXTURES;

      }

    else

      {

      return cubitface>0 ? NUM_TEXTURES : retFaceTetraBelongsTo(cubit-numO, size);

      }

    }

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

  ObjectSticker retSticker(int face)

    {

    if( mStickers==null )

      {

      float[][] STICKERS = new float[][] { { -0.4330127f, -0.25f, 0.4330127f, -0.25f, 0.0f, 0.5f } };

      float radius = 0.06f;

      float stroke = 0.07f;

      float[] radii = new float[] {radius,radius,radius};

      mStickers     = new ObjectSticker[STICKERS.length];

      mStickers[0]  = new ObjectSticker(STICKERS[0],null,radii,stroke);

      }

    return mStickers[face/NUM_FACE_COLORS];

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public Movement getMovement()

    {

    if( mMovement==null )

      {

      int numLayers = getNumLayers();

      if( mCuts==null ) getCuts(numLayers);

      getLayerRotatable(numLayers);

      mMovement = new Movement8(ROT_AXIS,mCuts,mLayerRotatable,numLayers,TYPE_NOT_SPLIT,NUM_ENABLED,ENABLED);

      }

    return mMovement;

    }

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

  public int[] getBasicAngle()

    {

    if( mBasicAngle ==null ) mBasicAngle = new int[] { 3,3,3,3 };

    return mBasicAngle;

    }

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

  public int getObjectName(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return R.string.diam2;

      case 3: return R.string.diam3;

      case 4: return R.string.diam4;

      }

    return 0;

    }

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

  public int getInventor(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return R.string.diam2_inventor;

      case 3: return R.string.diam3_inventor;

      case 4: return R.string.diam4_inventor;

      }

    return 0;

    }

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

  public int getComplexity(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return 4;

      case 3: return 6;

      case 4: return 8;

      }

    return 0;

    }

}