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

import android.content.res.Resources;

import org.distorted.objectlib.ObjectShape;

import org.distorted.objectlib.ObjectSticker;

import org.distorted.objectlib.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;

import org.distorted.objectlib.Movement;

import org.distorted.objectlib.Movement4;

import org.distorted.objectlib.ObjectList;

import org.distorted.objectlib.Twisty4;

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

public class TwistyJing 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}}

      };

  static final float F = 0.48f;  // length of the edge of the corner cubit. Keep<0.5

                                 // Assuming the length of the edge of the whole

                                 // tetrahedron is 2.0 (ie standard, equal to numLayers

  private ScrambleState[] mStates;

  private int[] mBasicAngle;

  private int[] mRotQuat;

  private Static4D[] mQuats;

  private float[][] mCuts;

  private boolean[][] mLayerRotatable;

  private float[][] mCenters;

  private int[][] mFaceMap;

  private ObjectSticker[] mStickers;

  private Movement mMovement;

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

  public TwistyJing(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.JING, res, scrWidth);

    }

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

  protected ScrambleState[] getScrambleStates()

    {

    if( mStates==null )

      {

      int[] tmp = {0,-1,0, 0,1,0, 1,-1,0, 1,1,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.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)

         };

    }

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

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

    }

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

  protected float[][] getCubitPositions(int size)

    {

    if( mCenters==null )

      {

      mCenters = new float[][]

         {

           { 0.000f, -SQ2/2, 1.000f },

           { 0.000f, -SQ2/2,-1.000f },

           {-1.000f,  SQ2/2, 0.000f },

           { 1.000f,  SQ2/2, 0.000f },

           { 0.000f, -SQ2/2, 0.000f },

           {-0.500f, 0.000f, 0.500f },

           { 0.500f, 0.000f, 0.500f },

           {-0.500f, 0.000f,-0.500f },

           { 0.500f, 0.000f,-0.500f },

           { 0.000f,  SQ2/2, 0.000f },

           { 0.000f,  SQ2/6, 1.0f/3 },

           { 0.000f,  SQ2/6,-1.0f/3 },

           {-1.0f/3, -SQ2/6, 0.000f },

           { 1.0f/3, -SQ2/6, 0.000f },

         };

      }

    return mCenters;

    }

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

  protected Static4D[] getQuats()

    {

    if( mQuats==null ) initializeQuats();

    return mQuats;

    }

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

  protected int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  protected int getNumStickerTypes(int numLayers)

    {

    return 3;

    }

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

  protected float[][] getCuts(int size)

    {

    if( mCuts==null )

      {

      float[] cut = { (F-0.5f)*(SQ6/3) };

      mCuts = new float[][] { cut,cut,cut,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 getNumCubitFaces()

    {

    return 6;

    }

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

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

    {

    if( mFaceMap==null )

      {

      // Colors of the faces of cubits.

      // GREEN 0 YELLOW 1 BLUE  2 RED 3

      // GREEN 4 YELLOW 5 BLUE  6 RED 7

      // GREEN 8 YELLOW 9 BLUE 10 RED 11

      mFaceMap = new int[][]

         {

           {  0,  3,  2, 12, 12, 12 },

           {  1,  2,  3, 12, 12, 12 },

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

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

           {  7,  6, 12, 12, 12, 12 },

           {  4,  6, 12, 12, 12, 12 },

           {  7,  4, 12, 12, 12, 12 },

           {  5,  6, 12, 12, 12, 12 },

           {  7,  5, 12, 12, 12, 12 },

           {  4,  5, 12, 12, 12, 12 },

           {  8, 12, 12, 12, 12, 12 },

           {  9, 12, 12, 12, 12, 12 },

           { 10, 12, 12, 12, 12, 12 },

           { 11, 12, 12, 12, 12, 12 },

         };

      }

    return mFaceMap[cubit][cubitface];

    }

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

  protected ObjectShape getObjectShape(int cubit, int numLayers)

    {

    int variant = getCubitVariant(cubit,numLayers);

    final float X = F/2;

    final float Y = F*SQ2/2;

    final float Z =-F/2;

    final float L = (2.0f-3*F);

    final float X2= L/2;

    final float Y2= L*SQ2/2;

    final float Z2=-L/2;

    final float D = F/L;

    final float G = 1.0f-F;

    if( variant==0 )

      {

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

          {

             { 0.0, 0.0, 0.0 },

             {   X,   Y,   Z },

             { 0.0, 2*Y, 2*Z },

             {  -X,   Y,   Z },

             { 0.0, 0.0,    -F },

             {   X,   Y,   Z-F },

             { 0.0, 2*Y, 2*Z-F },

             {  -X,   Y,   Z-F },

          };

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

          {

             {0,1,2,3},

             {1,0,4,5},

             {7,4,0,3},

             {1,5,6,2},

             {7,3,2,6},

             {4,7,6,5}

          };

      float[][] bands     = new float[][] { {0.015f,35,0.5f*F,F,5,1,1},{0.001f,35,0.5f*F,F,5,1,1} };

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

      float[][] corners   = new float[][] { {0.08f,0.20f*F},{0.07f,0.20f*F} };

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

      float[][] centers   = new float[][] { { 0.0f, F*SQ2/2, -F} };

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

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

      }

    else if( variant==1 )

      {

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

          {

             { 0.0, 0.0,     G },

             {   X,   Y,   Z+G },

             { 0.0, 2*Y, 2*Z+G },

             {  -X,   Y,   Z+G },

             { 0.0, 0.0,    -G },

             {   X,   Y,  -Z-G },

             { 0.0, 2*Y,-2*Z-G },

             {  -X,   Y,  -Z-G },

          };

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

          {

             {0,4,5,1},

             {3,7,4,0},

             {0,1,2,3},

             {4,7,6,5},

             {1,5,6,2},

             {2,6,7,3}

          };

      float[][] bands     = new float[][] { {0.015f,35,0.5f*F,F,5,1,1},{0.001f,35,0.5f*F,F,5,1,1} };

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

      float[][] corners   = new float[][] { {0.07f,0.20f*F} };

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

      float[][] centers   = new float[][] { { 0, F*SQ2/2, 0 } };

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

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

      }

    else

      {

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

          {

             {    0.0,     -2*Y2/3,   -2*Z2/3 },

             {      X2,       Y2/3,      Z2/3 },

             {     -X2,       Y2/3,      Z2/3 },

             {    0.0,     -2*Y2/3,-2*Z2/3+2*D*Z2 },

             {  X2-D*X2, Y2/3-D*Y2, Z2/3+D*Z2 },

             { -X2+D*X2, Y2/3-D*Y2, Z2/3+D*Z2 },

          };

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

          {

             {0,1,2},

             {3,5,4},

             {0,3,4,1},

             {5,3,0,2},

             {4,5,2,1}

          };

      float[][] bands     = new float[][] { {0.020f,35,0.20f*L,0.6f*L,5,1,1}, {0.001f,35,0.05f*L,0.1f*L,5,1,1} };

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

      float[][] corners   = new float[][] { {0.04f,0.6f*F} };

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

      float[][] centers   = new float[][] { { 0, -2*Y/3, 4*Z/3 } };

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

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

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

    return mQuats[mRotQuat[cubit]];

    }

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

  protected int getNumCubitVariants(int numLayers)

    {

    return 3;

    }

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

  protected int getCubitVariant(int cubit, int numLayers)

    {

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

    }

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

  protected ObjectSticker retSticker(int face)

    {

    if( mStickers==null )

      {

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

          {

             { 0.0f, -0.5f, 0.28867516f, 0.0f, 0.0f, 0.5f, -0.28867516f, 0.0f },

             { -0.5f, 0.11983269f, 0.27964598f, -0.43146032f, 0.3200817f, 0.007388768f, -0.09972769f, 0.30423886f },

             { 0.0f, -0.5f, 0.43301272f, 0.25f, -0.43301272f, 0.25f },

          };

      mStickers = new ObjectSticker[STICKERS.length];

      final float R1 = 0.05f;

      final float R2 = 0.10f;

      final float R3 = 0.03f;

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

      final float[] strokes = { 0.06f, 0.03f, 0.05f };

      for(int s=0; s<STICKERS.length; s++)

        {

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

        }

      }

    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,TYPE_NOT_SPLIT,ENABLED);

      }

    return mMovement;

    }

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

  public int[] getBasicAngle()

    {

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

    return mBasicAngle;

    }

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

  public int getObjectName(int numLayers)

    {

    return R.string.jing;

    }

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

  public int getInventor(int numLayers)

    {

    return R.string.jing_inventor;

    }

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

  public int getComplexity(int numLayers)

    {

    return 4;

    }

}