TwistyPuzzleLib

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

// 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.objectlib.objects;

import static org.distorted.objectlib.main.Movement.TYPE_NOT_SPLIT;

import android.content.res.Resources;

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

import org.distorted.objectlib.main.Movement;

import org.distorted.objectlib.main.Movement4;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.ObjectType;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSticker;

import org.distorted.objectlib.helpers.ScrambleState;

import org.distorted.objectlib.main.Twisty4;

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

public class TwistyPyraminx extends Twisty4

{

  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[][][] ENABLED = new int[][][]

      {

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

      };

  private ScrambleState[] mStates;

  private int[] mBasicAngle;

  private Static4D[] mQuats;

  private float[][] mCuts;

  private boolean[][] mLayerRotatable;

  private ObjectSticker[] mStickers;

  private Movement mMovement;

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

  public TwistyPyraminx(int[] numL, Static4D quat, Static3D move, DistortedTexture texture,

                        MeshSquare mesh, DistortedEffects effects, Resources res, int surfaceW, int surfaceH)

    {

    super(numL, numL[0], quat, move, texture, mesh, effects, res, surfaceW, surfaceH);

    }

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

  protected ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int[] numLayers = getNumLayers();

      initializeScrambleStates(numLayers[0]);

      }

    return mStates;

    }

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

  protected int getResource(int[] numLayers)

    {

    switch(numLayers[0])

      {

      case 3: return R.raw.pyra3;

      case 4: return R.raw.pyra4;

      case 5: return R.raw.pyra5;

      }

    return 0;

    }

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

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

    }

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

  protected int[] getSolvedQuats(int cubit, int[] numLayers)

    {

    if( mQuats==null ) initializeQuats();

    int status = retCubitSolvedStatus(cubit,numLayers);

    return status<0 ? null : buildSolvedQuats(Movement4.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

  protected float[][] getCubitPositions(int[] numLayers)

    {

    int numL = numLayers[0];

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

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

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

    addTetrahedralLattice(numL-1,      0,ret);

    addTetrahedralLattice(numL  ,numOcta,ret);

    return ret;

    }

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

  protected Static4D[] getQuats()

    {

    if( mQuats==null ) initializeQuats();

    return mQuats;

    }

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

  protected int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  protected int getNumStickerTypes(int[] numLayers)

    {

    return 1;

    }

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

  protected float[][] getCuts(int[] numLayers)

    {

    if( mCuts==null )

      {

      int numL = numLayers[0];

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

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

        {

        float cut = (1.0f+i-numL/4.0f)*(SQ6/3);

        mCuts[0][i] = cut;

        mCuts[1][i] = cut;

        mCuts[2][i] = cut;

        mCuts[3][i] = cut;

        }

      }

    return mCuts;

    }

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

  private void getLayerRotatable(int[] numLayers)

    {

    if( mLayerRotatable==null )

      {

      int numAxis = ROT_AXIS.length;

      mLayerRotatable = new boolean[numAxis][];

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

        {

        mLayerRotatable[i] = new boolean[numLayers[i]];

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

        }

      }

    }

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

  protected int getNumCubitFaces()

    {

    return 8;

    }

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

  private int getNumOctahedrons(int numLayers)

    {

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

    }

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

  private int faceColor(int cubit, int axis)

    {

    return CUBITS[cubit].getRotRow(axis) == 1 ? axis : NUM_TEXTURES;

    }

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

  protected int getFaceColor(int cubit, int cubitface, int[] numLayers)

    {

    int numL = numLayers[0];

    if( cubit< (numL-1)*numL*(numL+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;

      }

    }

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

  protected ObjectShape getObjectShape(int cubit, int[] numLayers)

    {

    int numL = numLayers[0];

    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 = numL==3? 6 : 5;

      int E = numL==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 = numL==3? 6 : 5;

      int E = numL==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);

      }

    }

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

  protected Static4D getQuat(int cubit, int[] numLayers)

    {

    if( mQuats==null ) initializeQuats();

    return mQuats[0];

    }

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

  protected int getNumCubitVariants(int[] numLayers)

    {

    return 2;

    }

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

  protected int getCubitVariant(int cubit, int[] numLayers)

    {

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

    }

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

  protected 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 radius = 0.06f;

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

      mStickers = new ObjectSticker[STICKERS.length];

      float stroke = 0.08f;

      if( ObjectControl.isInIconMode() )

        {

        int[] numLayers = getNumLayers();

        switch(numLayers[0])

          {

          case 2: stroke*=1.0f; break;

          case 3: stroke*=1.4f; break;

          case 4: stroke*=1.7f; break;

          default:stroke*=1.9f; break;

          }

        }

      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 Movement4(ROT_AXIS,mCuts,mLayerRotatable,numLayers[0],TYPE_NOT_SPLIT,ENABLED);

      }

    return mMovement;

    }

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

  public int[] getBasicAngle()

    {

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

    return mBasicAngle;

    }

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

  public ObjectType intGetObjectType(int[] numLayers)

    {

    switch(numLayers[0])

      {

      case 3: return ObjectType.PYRA_3;

      case 4: return ObjectType.PYRA_4;

      case 5: return ObjectType.PYRA_5;

      }

    return ObjectType.PYRA_3;

    }

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

  public int getObjectName(int[] numLayers)

    {

    switch(numLayers[0])

      {

      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[0])

      {

      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[0])

      {

      case 3: return 4;

      case 4: return 6;

      case 5: return 8;

      }

    return 4;

    }

}