Magic Cube

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

// Copyright 2021 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.library.main.DistortedEffects;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshSquare;

import org.distorted.library.type.Static4D;

import org.distorted.main.R;

import java.util.Random;

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

class TwistySquare1 extends TwistySquare

{

  private static final int NUM_STICKERS = 6;

  private final int[][] mPermittedAngles;

  private final int[] mCornerQuat;

  private int mPermittedUp, mPermittedDo;

  private ObjectSticker[] mStickers;

  private int[] mQuatNumber;

  private float[][] mCenters;

  private int[][] mBadCornerQuats;

  private int[][] mStickerColor;

  private int[][] mStickerType;

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

  TwistySquare1(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh,

                DistortedEffects effects, int[][] moves, Resources res, int scrWidth)

    {

    super(size, quat, texture, mesh, effects, moves, ObjectList.SQU1, res, scrWidth);

    if( mBasicAngle==null ) initializeBasicAngle();

    mLastRot = LAST_SL;

    mPermittedAngles = new int[2][mBasicAngle[0]];

    mCornerQuat = new int[8];

    }

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

  int[] getSolvedQuats(int cubit, int numLayers)

    {

    if( mQuats==null ) initializeQuats();

    int status = retCubitSolvedStatus(cubit,numLayers);

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

    }

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

  ObjectShape getObjectShape(int cubit, int numLayers)

    {

    int variant = getCubitVariant(cubit,numLayers);

    if( variant==0 )

      {

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

        {

         { -1.5-X, 0.5, 1.5 },

         {    0.0, 0.5, 1.5 },

         {    0.0, 0.5,-1.5 },

         { -1.5+X, 0.5,-1.5 },

         { -1.5-X,-0.5, 1.5 },

         {    0.0,-0.5, 1.5 },

         {    0.0,-0.5,-1.5 },

         { -1.5+X,-0.5,-1.5 }

        };

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

        {

         {0,1,2,3},

         {4,5,6,7},

         {4,5,1,0},

         {5,6,2,1},

         {6,7,3,2},

         {7,4,0,3}

        };

      float[][] bands     = new float[][] { {0.040f,35,0.8f,1.0f,5,2,1}, {0.020f,35,0.8f,1.0f,5,2,1}, {0.001f,35,0.8f,1.0f,5,2,1} };

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

      float[][] corners   = new float[][] { {0.03f,0.05f} };

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

      float[][] centers   = new float[][] { { -0.75f, 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);

      }

    else if( variant==1 )

      {

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

        {

         { -X, 0.5, 0.0 },

         { +X, 0.5, 0.0 },

         {0.0, 0.5,-1.5 },

         { -X,-0.5, 0.0 },

         { +X,-0.5, 0.0 },

         {0.0,-0.5,-1.5 },

        };

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

        {

         {0,1,2},

         {3,4,5},

         {3,4,1,0},

         {4,5,2,1},

         {5,3,0,2}

        };

      float[][] bands     = new float[][] { {0.038f,35,0.5f,0.9f, 5,2,1}, {0.001f,35,0.5f,0.9f, 5,2,1} };

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

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

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

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

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

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

      }

    else

      {

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

        {

         { X-1.5, 0.5,  0.0 },

         {   0.0, 0.5,  0.0 },

         {   0.0, 0.5,X-1.5 },

         {  -1.5, 0.5, -1.5 },

         { X-1.5,-0.5,  0.0 },

         {   0.0,-0.5,  0.0 },

         {   0.0,-0.5,X-1.5 },

         {  -1.5,-0.5, -1.5 }

        };

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

        {

         {0,1,2,3},

         {4,5,6,7},

         {4,5,1,0},

         {5,6,2,1},

         {7,4,0,3},

         {6,7,3,2}

        };

      float[][] bands     = new float[][] { {0.038f,35,0.9f,1.0f, 5,2,1}, {0.001f,35,0.9f,1.0f, 5,2,1} };

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

      float[][] corners   = new float[][] { {0.05f,0.13f} };

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

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

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

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

      }

    }

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

  Static4D getQuat(int cubit, int numLayers)

    {

    if( mQuats==null ) initializeQuats();

    if( mQuatNumber ==null )

      {

      mQuatNumber = new int[]

        {

        0, 6,

        0, 9, 6, 3, 18, 15, 12, 21,

        0, 9, 6, 3, 15, 12, 21, 18

        };

      }

    return mQuats[mQuatNumber[cubit]];

    }

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

  int getNumCubitVariants(int numLayers)

    {

    return 3;

    }

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

  int getCubitVariant(int cubit, int numLayers)

    {

    return cubit<2 ? 0 : (cubit<10 ? 1:2);

    }

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

  ObjectSticker retSticker(int face)

    {

    if( mStickers==null )

      {

      float[][] STICKERS = new float[][]

        {

          { -0.5f, -0.26289170f, 0.5f, -0.26289170f, 0.5f, 0.26289170f, -0.5f, 0.26289170f }, // middle front

          { -0.5f, -0.16666667f, 0.5f, -0.16666667f, 0.5f, 0.16666667f, -0.5f, 0.16666667f }, // middle right

          { -0.5f, -0.45534182f, 0.5f, -0.45534182f, 0.5f, 0.45534182f, -0.5f, 0.45534182f }, // middle back

          { -0.20096192f, -0.25f, 0.20096192f, -0.25f, 0.0f, 0.5f },                          // edge top

          { -0.40192384f, -0.5f, 0.40192384f, -0.5f, 0.40192384f, 0.5f, -0.40192384f, 0.5f }, // edge face

          { -0.2637079f, -0.38185397f, 0.38185397f, -0.38185397f, 0.38185397f, 0.2637079f, -0.5f, 0.5f } // corner top

        };

      final float R1 = 0.06f;

      final float R2 = 0.04f;

      final float R3 = 0.11f;

      final float R4 = 0.03f;

      final float R5 = 0.11f;

      final float R6 = 0.08f;

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

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

      mStickers = new ObjectSticker[NUM_STICKERS];

      for(int s=0; s<NUM_STICKERS; s++)

        {

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

        }

      }

    return mStickers[face/NUM_FACES];

    }

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

  float[][] getCubitPositions(int numLayers)

    {

    if( mCenters==null )

      {

      mCenters = new float[][]

        {

         { 1.5f, 0.0f, 0.0f },

         {-1.5f, 0.0f, 0.0f },

         { 0.0f, 1.0f, 1.5f },

         { 1.5f, 1.0f, 0.0f },

         { 0.0f, 1.0f,-1.5f },

         {-1.5f, 1.0f, 0.0f },

         { 0.0f,-1.0f, 1.5f },

         { 1.5f,-1.0f, 0.0f },

         { 0.0f,-1.0f,-1.5f },

         {-1.5f,-1.0f, 0.0f },

         { 1.0f, 1.0f, 2.0f, 2.0f, 1.0f, 1.0f },

         { 1.0f, 1.0f,-2.0f, 2.0f, 1.0f,-1.0f },

         {-1.0f, 1.0f,-2.0f,-2.0f, 1.0f,-1.0f },

         {-1.0f, 1.0f, 2.0f,-2.0f, 1.0f, 1.0f },

         { 1.0f,-1.0f, 2.0f, 2.0f,-1.0f, 1.0f },

         { 1.0f,-1.0f,-2.0f, 2.0f,-1.0f,-1.0f },

         {-1.0f,-1.0f,-2.0f,-2.0f,-1.0f,-1.0f },

         {-1.0f,-1.0f, 2.0f,-2.0f,-1.0f, 1.0f }

        };

      }

    return mCenters;

    }

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

  int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  int getNumStickerTypes(int numLayers)

    {

    return NUM_STICKERS;

    }

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

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

    {

    if( mStickerColor==null )

      {

      // YELLOW 0 WHITE 1 BLUE 2 GREEN 3 RED 4 ORANGE 5

      mStickerColor = new int[][]

        {

          { 0, 0, 4, 0, 5, 0 },

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

          { 2, 0, 4, 0, 0, 0 },

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

          { 2, 0, 5, 0, 0, 0 },

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

          { 3, 0, 4, 0, 0, 0 },

          { 3, 0, 0, 0, 0, 0 },

          { 3, 0, 5, 0, 0, 0 },

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

          { 2, 0, 4, 0, 0, 0 },

          { 2, 0, 0, 5, 0, 0 },

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

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

          { 3, 0, 0, 4, 0, 0 },

          { 3, 0, 5, 0, 0, 0 },

          { 3, 0, 1, 5, 0, 0 },

          { 3, 0, 4, 1, 0, 0 },

        };

      }

    if( mStickerType==null )

      {

      mStickerType = new int[][]

        {

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

          {             3,NUM_STICKERS,4,NUM_STICKERS,NUM_STICKERS,NUM_STICKERS },

          {             5,NUM_STICKERS,2,           2,NUM_STICKERS,NUM_STICKERS }

        };

      }

    int variant = getCubitVariant(cubit,numLayers);

    return mStickerType[variant][cubitface]*FACE_COLORS.length + mStickerColor[cubit][cubitface];

    }

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

  private boolean cornerIsUp(int index)

    {

    return ((index<4) ^ (mCornerQuat[index]>=12));

    }

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

  private boolean cornerIsLeft(int index)

    {

    int q = mCornerQuat[index];

    switch(index)

      {

      case 0:

      case 4: return ((q>=3 && q<= 7) || (q>=18 && q<=22));

      case 1:

      case 5: return ((q>=6 && q<=10) || (q>=15 && q<=19));

      case 2:

      case 6: return ((q==0 || q==1 || (q>=9 && q<=11)) || (q>=12 && q<=16));

      case 3:

      case 7: return ((q>=0 && q<=4) || (q==12 || q==13 || (q>=21 && q<=23)));

      }

    return false;

    }

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

  private boolean quatIsBad(int quatIndex, int corner)

    {

    if( mBadCornerQuats ==null )

      {

      // quat indices that make corner cubits bandage the puzzle.

      mBadCornerQuats = new int[][] { { 2, 8,17,23}, { 5,11,14,20} };

      }

    int index = (corner%2);

    return ( quatIndex== mBadCornerQuats[index][0] ||

             quatIndex== mBadCornerQuats[index][1] ||

             quatIndex== mBadCornerQuats[index][2] ||

             quatIndex== mBadCornerQuats[index][3]  );

    }

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

  private boolean isPermittedDo(int angle)

    {

    if( mQuatMult==null ) initializeQuatMult();

    for(int corner=0; corner<8; corner++)

      {

      if( !cornerIsUp(corner) )

        {

        int currQuat = mCornerQuat[corner];

        int finalQuat= mQuatMult[angle][currQuat];

        if( quatIsBad(finalQuat,corner) ) return false;

        }

      }

    return true;

    }

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

  private boolean isPermittedUp(int angle)

    {

    if( mQuatMult==null ) initializeQuatMult();

    for(int corner=0; corner<8; corner++)

      {

      if( cornerIsUp(corner) )

        {

        int currQuat = mCornerQuat[corner];

        int finalQuat= mQuatMult[angle][currQuat];

        if( quatIsBad(finalQuat,corner) ) return false;

        }

      }

    return true;

    }

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

  private void computePermittedAngles()

    {

    if( mBasicAngle==null ) initializeBasicAngle();

    mPermittedDo = 0;

    for(int angle=0; angle<mBasicAngle[0]; angle++)

      {

      if( isPermittedDo(angle ) ) mPermittedAngles[0][mPermittedDo++] = angle;

      }

    mPermittedUp = 0;

    for(int angle=0; angle<mBasicAngle[0]; angle++)

      {

      if( isPermittedUp(angle ) ) mPermittedAngles[1][mPermittedUp++] = angle;

      }

    }

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

  private int getNextAngle(Random rnd, int layer)

    {

    if( mBasicAngle==null ) initializeBasicAngle();

    int basic = mBasicAngle[0];

    int num = layer==0 ? mPermittedDo:mPermittedUp;

    int index = rnd.nextInt(num);

    int angle = mPermittedAngles[layer][index];

    return angle<basic/2 ? -angle : basic-angle;

    }

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

  private int getNextAngleNotZero(Random rnd, int layer)

    {

    if( mBasicAngle==null ) initializeBasicAngle();

    int basic = mBasicAngle[0];

    int num = layer==0 ? mPermittedDo:mPermittedUp;

    int index = rnd.nextInt(num-1);

    int angle = mPermittedAngles[layer][index+1];

    return angle<basic/2 ? -angle : basic-angle;

    }

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

  private int makeQuat(int axis,int index)

    {

    if( axis==1 ) return 13;

    if( index<0 ) index+=12;

    return index;

    }

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

  private boolean cornerBelongs(int index, int axis, int layer)

    {

    if( axis==0 )

      {

      boolean up = cornerIsUp(index);

      return ((up && layer==2) || (!up && layer==0));

      }

    else

      {

      boolean le = cornerIsLeft(index);

      return ((le && layer==0) || (!le && layer==1));

      }

    }

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

  private void updateCornerQuats(int[] rotInfo)

    {

    if( mQuatMult==null ) initializeQuatMult();

    int axis = rotInfo[0];

    int layer= rotInfo[1];

    int index=-rotInfo[2];

    int quat = makeQuat(axis,index);

    for(int corner=0; corner<8; corner++)

      {

      if( cornerBelongs(corner,axis,layer) )

        {

        int curr = mCornerQuat[corner];

        mCornerQuat[corner] = mQuatMult[quat][curr];

        }

      }

    }

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

// PUBLIC API

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

    {

    int layer, nextAngle;

    if( curr==0 )

      {

      for(int corner=0; corner<8; corner++) mCornerQuat[corner] = 0;

      mLastRot = rnd.nextInt(4);

      computePermittedAngles();

      }

    switch(mLastRot)

      {

      case LAST_SL: layer = rnd.nextInt(2);

                    nextAngle = getNextAngle(rnd,layer);

                    if( nextAngle==0 )

                      {

                      layer = 1-layer;

                      nextAngle = getNextAngleNotZero(rnd,layer);

                      }

                    scramble[curr][0] = 0;

                    scramble[curr][1] = 2*layer;

                    scramble[curr][2] = nextAngle;

                    mLastRot = layer==0 ? LAST_LO : LAST_UP;

                    updateCornerQuats(scramble[curr]);

                    break;

      case LAST_LO:

      case LAST_UP: layer = mLastRot==LAST_LO ? 1:0;

                    nextAngle = getNextAngle(rnd,layer);

                    if( nextAngle!=0 )

                      {

                      scramble[curr][0] = 0;

                      scramble[curr][1] = 2*layer;

                      scramble[curr][2] = nextAngle;

                      updateCornerQuats(scramble[curr]);

                      mLastRot = LAST_UL;

                      }

                    else

                      {

                      scramble[curr][0] = 1;

                      scramble[curr][1] = rnd.nextInt(2);

                      scramble[curr][2] = 1;

                      mLastRot = LAST_SL;

                      updateCornerQuats(scramble[curr]);

                      computePermittedAngles();

                      }

                    break;

      case LAST_UL: scramble[curr][0] = 1;

                    scramble[curr][1] = rnd.nextInt(2);

                    scramble[curr][2] = 1;

                    mLastRot = LAST_SL;

                    updateCornerQuats(scramble[curr]);

                    computePermittedAngles();

                    break;

      }

    }

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

  public int getObjectName(int numLayers)

    {

    return R.string.squa1;

    }

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

  public int getInventor(int numLayers)

    {

    return R.string.squa1_inventor;

    }

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

  public int getComplexity(int numLayers)

    {

    return 9;

    }

}