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;

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

public class TwistyPyraminx extends TwistyObject

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

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

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

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

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

         };

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

         {

           COLOR_GREEN , COLOR_YELLOW,

           COLOR_BLUE  , COLOR_RED

         };

  private ScrambleState[] mStates;

  private int[] mBasicAngle;

  private Static4D[] mQuats;

  private ObjectSticker[] mStickers;

  private Movement mMovement;

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

  TwistyPyraminx(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.PYRA, res, scrWidth);

    }

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

  ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int numLayers = getNumLayers();

      initializeScrambleStates(numLayers);

      }

    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.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),

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

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

         };

    }

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

  private int[][] generateState(int start, int end)

    {

    int len = end-start+1;

    int[] tmp = new int[6*len];

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

      {

      tmp[6*i  ] = start;

      tmp[6*i+1] = -1;

      tmp[6*i+2] = start;

      tmp[6*i+3] = start;

      tmp[6*i+4] = +1;

      tmp[6*i+5] = start;

      start++;

      }

    return new int[][] {tmp,tmp,tmp,tmp};

    }

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

  private void initializeScrambleStates(int numLayers)

    {

    mStates = new ScrambleState[numLayers];

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

      {

      mStates[i] = new ScrambleState( generateState(0,numLayers-1-i) );

      }

    mStates[numLayers-1] = new ScrambleState( generateState(1,numLayers-2) );

    }

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

  int[] getSolvedQuats(int cubit, int numLayers)

    {

    if( mQuats==null ) initializeQuats();

    int status = retCubitSolvedStatus(cubit,numLayers);

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

    }

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

  private void addTetrahedralLattice(int size, int index, float[][] pos)

    {

    final float DX = 1.0f;

    final float DY = SQ2/2;

    final float DZ = 1.0f;

    float startX = 0.0f;

    float startY =-DY*(size-1)/2;

    float startZ = DZ*(size-1)/2;

    for(int layer=0; layer<size; layer++)

      {

      float currX = startX;

      float currY = startY;

      for(int x=0; x<layer+1; x++)

        {

        float currZ = startZ;

        for(int z=0; z<size-layer; z++)

          {

          pos[index] = new float[] {currX,currY,currZ};

          index++;

          currZ -= DZ;

          }

        currX += DX;

        }

      startX-=DX/2;

      startY+=DY;

      startZ-=DZ/2;

      }

    }

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

// there are (n^3-n)/6 octahedrons and ((n+1)^3 - (n+1))/6 tetrahedrons

  float[][] getCubitPositions(int size)

    {

    int numOcta = (size-1)*size*(size+1)/6;

    int numTetra= size*(size+1)*(size+2)/6;

    float[][] ret = new float[numOcta+numTetra][];

    addTetrahedralLattice(size-1,      0,ret);

    addTetrahedralLattice(size  ,numOcta,ret);

    return ret;

    }

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

  Static4D[] getQuats()

    {

    if( mQuats==null ) initializeQuats();

    return mQuats;

    }

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

  int getNumFaceColors()

    {

    return FACE_COLORS.length;

    }

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

  int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  int getNumStickerTypes(int numLayers)

    {

    return 1;

    }

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

  float[][] getCuts(int numLayers)

    {

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

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

      {

      float cut = (1.0f+i-numLayers/3.0f)*(SQ6/3);

      cuts[0][i] = cut;

      cuts[1][i] = cut;

      cuts[2][i] = cut;

      cuts[3][i] = cut;

      }

    return cuts;

    }

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

  int getNumCubitFaces()

    {

    return 8;

    }

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

  float getScreenRatio()

    {

    return 0.88f;

    }

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

  boolean shouldResetTextureMaps()

    {

    return false;

    }

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

  private int getNumOctahedrons(int numLayers)

    {

    return (numLayers-1)*numLayers*(numLayers+1)/6;

    }

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

  private int faceColor(int cubit, int axis)

    {

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

    }

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

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

    {

    if( cubit< (size-1)*size*(size+1)/6 )

      {

      switch( cubitface )

        {

        case 0: return faceColor(cubit,0);

        case 2: return faceColor(cubit,1);

        case 5: return faceColor(cubit,3);

        case 7: return faceColor(cubit,2);

        default:return NUM_TEXTURES;

        }

      }

    else

      {

      return cubitface<NUM_TEXTURES ? faceColor(cubit,cubitface) : NUM_TEXTURES;

      }

    }

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

  ObjectShape getObjectShape(int cubit, int numLayers)

    {

    int variant = getCubitVariant(cubit,numLayers);

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

      int N = numLayers==3? 6 : 5;

      int E = numLayers==3? 2 : 1;

      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},{3,0,1},{3,2,0},{2,3,1} };

      int N = numLayers==3? 6 : 5;

      int E = numLayers==3? 2 : 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.06f,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();

    return mQuats[0];

    }

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

  int getNumCubitVariants(int numLayers)

    {

    return 2;

    }

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

  int getCubitVariant(int cubit, int numLayers)

    {

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

    }

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

  int getColor(int face)

    {

    return FACE_COLORS[face];

    }

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

  ObjectSticker retSticker(int face)

    {

    if( mStickers==null )

      {

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

      final float stroke = 0.08f;

      final float radius = 0.06f;

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

      mStickers = new ObjectSticker[STICKERS.length];

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

      }

    return mStickers[face/NUM_FACE_COLORS];

    }

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

// SQ6/3 = height of the tetrahedron

  float returnMultiplier()

    {

    return getNumLayers()/(SQ6/3);

    }

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

// public API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public Movement getMovement()

    {

    if( mMovement==null ) mMovement = new MovementPyraminx();

    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 3: return R.string.pyra3;

      case 4: return R.string.pyra4;

      case 5: return R.string.pyra5;

      }

    return R.string.pyra3;

    }

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

  public int getInventor(int numLayers)

    {

    switch(numLayers)

      {

      case 3: return R.string.pyra3_inventor;

      case 4: return R.string.pyra4_inventor;

      case 5: return R.string.pyra5_inventor;

      }

    return R.string.pyra3_inventor;

    }

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

  public int getComplexity(int numLayers)

    {

    switch(numLayers)

      {

      case 3: return 4;

      case 4: return 6;

      case 5: return 8;

      }

    return 4;

    }

}