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

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

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

public class TwistyCube extends Twisty6

{

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

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

      {

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

      };

  private ScrambleState[] mStates;

  private Static4D[] mQuats;

  private float[][] mCuts;

  private boolean[][] mLayerRotatable;

  private int[] mBasicAngle;

  private ObjectSticker[] mStickers;

  private Movement mMovement;

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

  public TwistyCube(int size, Static4D quat, Static3D move, DistortedTexture texture,

                    MeshSquare mesh, DistortedEffects effects, Resources res, int scrWidth)

    {

    super(size, size, quat, move, texture, mesh, effects, res, scrWidth);

    }

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

  protected ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int size = getNumLayers();

      int[][] m = new int[16][];

      for(int i=1; i<16; i++) m[i] = createEdges(size,i);

      mStates = new ScrambleState[]

        {

        new ScrambleState( new int[][] { m[ 1], m[ 2], m[ 3] } ),  //  0 0

        new ScrambleState( new int[][] {  null, m[ 4], m[ 5] } ),  //  1 x

        new ScrambleState( new int[][] { m[ 6],  null, m[ 7] } ),  //  2 y

        new ScrambleState( new int[][] { m[ 8], m[ 9],  null } ),  //  3 z

        new ScrambleState( new int[][] { m[10],  null, m[ 7] } ),  //  4 xy

        new ScrambleState( new int[][] { m[11], m[ 9],  null } ),  //  5 xz

        new ScrambleState( new int[][] {  null, m[12], m[ 5] } ),  //  6 yx

        new ScrambleState( new int[][] { m[ 8], m[13],  null } ),  //  7 yz

        new ScrambleState( new int[][] {  null, m[ 4], m[14] } ),  //  8 zx

        new ScrambleState( new int[][] { m[ 6],  null, m[15] } ),  //  9 zy

        new ScrambleState( new int[][] {  null,  null, m[ 5] } ),  // 10 xyx

        new ScrambleState( new int[][] {  null, m[ 4],  null } ),  // 11 xzx

        new ScrambleState( new int[][] {  null,  null, m[ 7] } ),  // 12 yxy

        new ScrambleState( new int[][] { m[ 6],  null,  null } ),  // 13 yzy

        new ScrambleState( new int[][] {  null, m[ 9],  null } ),  // 14 zxz

        new ScrambleState( new int[][] { m[ 8],  null,  null } ),  // 15 zyz

        };

      }

    return mStates;

    }

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

  protected int getResource(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return R.raw.cube2;

      case 3: return R.raw.cube3;

      case 4: return R.raw.cube4;

      case 5: return R.raw.cube5;

      }

    return 0;

    }

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

  private int[] createEdges(int size, int vertex)

    {

    int[] ret = new int[9*size];

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

      {

      ret[9*l  ] = l;

      ret[9*l+1] =-1;

      ret[9*l+2] = vertex;

      ret[9*l+3] = l;

      ret[9*l+4] = 1;

      ret[9*l+5] = vertex;

      ret[9*l+6] = l;

      ret[9*l+7] = 2;

      ret[9*l+8] = vertex;

      }

    return ret;

    }

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

  private void initializeQuats()

    {

    mQuats = 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( SQ2/2,  SQ2/2,  0.0f ,   0.0f),

         new Static4D( SQ2/2, -SQ2/2,  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.0f,   0.0f,  SQ2/2),

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

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

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

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

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

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

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

         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)

         };

    }

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

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

    {

    if( mQuats ==null ) initializeQuats();

    int status = retCubitSolvedStatus(cubit,numLayers);

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

    }

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

  private int getNumCornersAndEdges(int numLayers)

    {

    return numLayers==1 ? 1 : 12*(numLayers-2) + 8;

    }

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

  protected ObjectShape getObjectShape(int cubit, int numLayers)

    {

    int extraI, extraV, num;

    float height;

    switch(numLayers)

      {

      case 2 : num = 6; extraI = 2; extraV = 2; height = 0.045f; break;

      case 3 : num = 5; extraI = 2; extraV = 2; height = 0.045f; break;

      case 4 : num = 5; extraI = 1; extraV = 1; height = 0.045f; break;

      default: num = 5; extraI = 0; extraV = 0; height = 0.045f; break;

      }

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

          {

              { 0.5, 0.5, 0.5 },

              { 0.5, 0.5,-0.5 },

              { 0.5,-0.5, 0.5 },

              { 0.5,-0.5,-0.5 },

              {-0.5, 0.5, 0.5 },

              {-0.5, 0.5,-0.5 },

              {-0.5,-0.5, 0.5 },

              {-0.5,-0.5,-0.5 },

          };

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

          {

              {2,3,1,0},

              {7,6,4,5},

              {4,0,1,5},

              {7,3,2,6},

              {6,2,0,4},

              {3,7,5,1}

          };

    float[][] bands     = new float[][] { {height,35,0.5f,0.7f,num,extraI,extraV} };

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

    float[][] corners   = new float[][] { {0.036f,0.12f} };

    int[] cornerIndices = new int[] { 0,0,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,0,0 };

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

    }

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

  protected float[][] getCubitPositions(int numLayers)

    {

    if( numLayers==1 ) return new float[][] {{ 0.0f, 0.0f, 0.0f }};

    int numCubits = getNumCornersAndEdges(numLayers) + 6*(numLayers-2)*(numLayers-2);

    float[][] tmp = new float[numCubits][];

    final float LEN = 0.5f*(numLayers-1);

    int currentPosition = 0;

    tmp[currentPosition++] = new float[] {-LEN,-LEN,-LEN};

    tmp[currentPosition++] = new float[] {-LEN,-LEN,+LEN};

    tmp[currentPosition++] = new float[] {-LEN,+LEN,-LEN};

    tmp[currentPosition++] = new float[] {-LEN,+LEN,+LEN};

    tmp[currentPosition++] = new float[] {+LEN,-LEN,-LEN};

    tmp[currentPosition++] = new float[] {+LEN,-LEN,+LEN};

    tmp[currentPosition++] = new float[] {+LEN,+LEN,-LEN};

    tmp[currentPosition++] = new float[] {+LEN,+LEN,+LEN};

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

      tmp[currentPosition++] = new float[] { i-LEN,  -LEN,  -LEN };

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

      tmp[currentPosition++] = new float[] { i-LEN,  -LEN,  +LEN };

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

      tmp[currentPosition++] = new float[] { i-LEN,  +LEN,  -LEN };

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

      tmp[currentPosition++] = new float[] { i-LEN,  +LEN,  +LEN };

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

      tmp[currentPosition++] = new float[] {  -LEN, i-LEN,  -LEN };

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

      tmp[currentPosition++] = new float[] {  -LEN, i-LEN,  +LEN };

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

      tmp[currentPosition++] = new float[] {  +LEN, i-LEN,  -LEN };

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

      tmp[currentPosition++] = new float[] {  +LEN, i-LEN,  +LEN };

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

      tmp[currentPosition++] = new float[] {  -LEN,  -LEN, i-LEN };

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

      tmp[currentPosition++] = new float[] {  -LEN,  +LEN, i-LEN };

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

      tmp[currentPosition++] = new float[] {  +LEN,  -LEN, i-LEN };

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

      tmp[currentPosition++] = new float[] {  +LEN,  +LEN, i-LEN };

    for(int y=1; y<numLayers-1; y++)

      for(int z=1; z<numLayers-1; z++)

        tmp[currentPosition++] = new float[] {+LEN,y-LEN,z-LEN};

    for(int y=1; y<numLayers-1; y++)

      for(int z=1; z<numLayers-1; z++)

        tmp[currentPosition++] = new float[] {-LEN,y-LEN,z-LEN};

    for(int x=1; x<numLayers-1; x++)

      for(int z=1; z<numLayers-1; z++)

        tmp[currentPosition++] = new float[] {x-LEN,+LEN,z-LEN};

    for(int x=1; x<numLayers-1; x++)

      for(int z=1; z<numLayers-1; z++)

        tmp[currentPosition++] = new float[] {x-LEN,-LEN,z-LEN};

    for(int x=1; x<numLayers-1; x++)

      for(int y=1; y<numLayers-1; y++)

        tmp[currentPosition++] = new float[] {x-LEN,y-LEN,+LEN};

    for(int x=1; x<numLayers-1; x++)

      for(int y=1; y<numLayers-1; y++)

        tmp[currentPosition++] = new float[] {x-LEN,y-LEN,-LEN};

    return tmp;

    }

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

  protected Static4D getQuat(int cubit, int numLayers)

    {

    if( mQuats ==null ) initializeQuats();

    int num = cubit - getNumCornersAndEdges(numLayers);

    if( num>=0 )

      {

      int face = num/((numLayers-2)*(numLayers-2));

      switch(face)

        {

        case 0: return mQuats[13];

        case 1: return mQuats[12];

        case 2: return mQuats[ 8];

        case 3: return mQuats[ 9];

        case 4: return mQuats[ 0];

        case 5: return mQuats[ 1];

        }

      }

    return mQuats[0];

    }

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

  protected int getNumCubitVariants(int numLayers)

    {

    return numLayers>2 ? 2:1;

    }

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

  protected int getCubitVariant(int cubit, int numLayers)

    {

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

    }

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

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

    {

    int cornersAndEdges = getNumCornersAndEdges(numLayers);

    if( cubit<cornersAndEdges )

      {

      return CUBITS[cubit].getRotRow(cubitface/2) == (cubitface%2==0 ? (1<<(numLayers-1)):1) ? cubitface : NUM_TEXTURES;

      }

    else

      {

      int numCentersPerFace = (numLayers-2)*(numLayers-2);

      return cubitface == 4 ? (cubit-cornersAndEdges)/numCentersPerFace : NUM_TEXTURES;

      }

    }

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

  protected ObjectSticker retSticker(int face)

    {

    if( mStickers==null )

      {

      final float[][] STICKERS = new float[][]  { { -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f } };

      final float radius = 0.10f;

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

      mStickers = new ObjectSticker[STICKERS.length];

      float stroke = 0.08f;

      if( ObjectControl.isInIconMode() )

        {

        switch(getNumLayers())

          {

          case 2: stroke*=1.8f; break;

          case 3: stroke*=2.0f; break;

          case 4: stroke*=2.1f; break;

          default:stroke*=2.2f; break;

          }

        }

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

      }

    return mStickers[face/NUM_FACE_COLORS];

    }

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

  protected Static4D[] getQuats()

    {

    if( mQuats ==null ) initializeQuats();

    return mQuats;

    }

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

  protected float[][] getCuts(int numLayers)

    {

    if( numLayers<2 ) return null;

    if( mCuts==null )

      {

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

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

        {

        float cut = (2-numLayers)*0.5f + i;

        mCuts[0][i] = cut;

        mCuts[1][i] = cut;

        mCuts[2][i] = cut;

        }

      }

    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;

      }

    }

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

  protected int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  protected int getNumStickerTypes(int numLayers)

    {

    return 1;

    }

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

  protected int getNumCubitFaces()

    {

    return 6;

    }

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

// 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 Movement6(ROT_AXIS,mCuts,mLayerRotatable,numLayers,TYPE_NOT_SPLIT,ENABLED);

      }

    return mMovement;

    }

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

  public int[] getBasicAngle()

    {

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

    return mBasicAngle;

    }

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

  public ObjectType intGetObjectType(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return ObjectType.CUBE_2;

      case 3: return ObjectType.CUBE_3;

      case 4: return ObjectType.CUBE_4;

      case 5: return ObjectType.CUBE_5;

      }

    return ObjectType.CUBE_3;

    }

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

  public int getObjectName(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return R.string.cube2;

      case 3: return R.string.cube3;

      case 4: return R.string.cube4;

      case 5: return R.string.cube5;

      }

    return R.string.cube3;

    }

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

  public int getInventor(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return R.string.cube2_inventor;

      case 3: return R.string.cube3_inventor;

      case 4: return R.string.cube4_inventor;

      case 5: return R.string.cube5_inventor;

      }

    return R.string.cube3_inventor;

    }

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

  public int getComplexity(int numLayers)

    {

    switch(numLayers)

      {

      case 2: return 4;

      case 3: return 6;

      case 4: return 8;

      case 5: return 10;

      }

    return 6;

    }

}