Magic Cube

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

// Copyright 2020 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 TwistyIvy extends TwistyObject

{

  // the four rotation axis of a RubikIvy. Must be normalized.

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

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

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

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

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

         };

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

         {

           COLOR_YELLOW, COLOR_WHITE,

           COLOR_BLUE  , COLOR_GREEN,

           COLOR_RED   , COLOR_ORANGE

         };

  private static final int NUM_STICKERS = 2;

  public static final float IVY_D = 0.003f;

  private static final int  IVY_N = 8;

  private static final int FACES_PER_CUBIT =6;

  private ScrambleState[] mStates;

  private int[] mBasicAngle;

  private Static4D[] mQuats;

  private int[][] mFaceMap;

  private ObjectSticker[] mStickers;

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

  TwistyIvy(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.IVY, res, scrWidth);

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

      };

    }

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

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

         };

    }

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

  int[] getSolvedQuats(int cubit, int numLayers)

    {

    if( mQuats==null ) initializeQuats();

    int status = retCubitSolvedStatus(cubit,numLayers);

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

    }

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

  float getScreenRatio()

    {

    return 1.0f;

    }

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

  Static4D[] getQuats()

    {

    if( mQuats==null ) initializeQuats();

    return mQuats;

    }

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

  int getNumFaces()

    {

    return FACE_COLORS.length;

    }

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

  boolean shouldResetTextureMaps()

    {

    return false;

    }

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

  int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  int getNumStickerTypes(int numLayers)

    {

    return NUM_STICKERS;

    }

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

  float[][] getCuts(int numLayers)

    {

    float[] cut = new float[] {0.0f};

    return new float[][] { cut,cut,cut,cut };

    }

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

  int getNumCubitFaces()

    {

    return FACES_PER_CUBIT;

    }

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

  float[][] getCubitPositions(int numLayers)

    {

    final float DIST_CORNER = (numLayers-1)*0.50f;

    final float DIST_CENTER = (numLayers-1)*0.50f;

    final float[][] CENTERS = new float[10][];

    CENTERS[0] = new float[] { DIST_CORNER, DIST_CORNER, DIST_CORNER };

    CENTERS[1] = new float[] {-DIST_CORNER, DIST_CORNER,-DIST_CORNER };

    CENTERS[2] = new float[] {-DIST_CORNER,-DIST_CORNER, DIST_CORNER };

    CENTERS[3] = new float[] { DIST_CORNER,-DIST_CORNER,-DIST_CORNER };

    CENTERS[4] = new float[] { DIST_CENTER,           0,           0 };

    CENTERS[5] = new float[] {-DIST_CENTER,           0,           0 };

    CENTERS[6] = new float[] {           0, DIST_CENTER,           0 };

    CENTERS[7] = new float[] {           0,-DIST_CENTER,           0 };

    CENTERS[8] = new float[] {           0,           0, DIST_CENTER };

    CENTERS[9] = new float[] {           0,           0,-DIST_CENTER };

    return CENTERS;

    }

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

  ObjectShape getObjectShape(int cubit, int numLayers)

    {

    int variant = getCubitVariant(cubit,numLayers);

    if( variant==0 )

      {

      final float angle = (float)Math.PI/(2*IVY_N);

      final float CORR  = 1.0f - 2*IVY_D;

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

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

      int[] cornerIndices= new int[3*(IVY_N+1)+4];

      int[] centerIndices= new int[3*(IVY_N+1)+4];

      double[][] vertices= new double[3*(IVY_N+1)+4][3];

      int[][] vertIndices= new int[6][IVY_N+4];

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

      float[][] bands =

        {

          {+0.015f,20,0.2f,0.5f,7,1,2},

          {-0.100f,20,0.2f,0.0f,2,1,2}

        };

      for(int i=0; i<3*(IVY_N+1); i++)

        {

        cornerIndices[i+4] = -1;

        centerIndices[i+4] = -1;

        }

      cornerIndices[0] = 1;

      cornerIndices[1] = 0;

      cornerIndices[2] = 0;

      cornerIndices[3] = 0;

      centerIndices[0] = 0;

      centerIndices[1] = 0;

      centerIndices[2] = 0;

      centerIndices[3] = 0;

      vertices[0][0] = 0.0;

      vertices[0][1] = 0.0;

      vertices[0][2] = 0.0;

      vertices[1][0] =-1.0;

      vertices[1][1] = 0.0;

      vertices[1][2] = 0.0;

      vertices[2][0] = 0.0;

      vertices[2][1] =-1.0;

      vertices[2][2] = 0.0;

      vertices[3][0] = 0.0;

      vertices[3][1] = 0.0;

      vertices[3][2] =-1.0;

      vertIndices[0][0] = 2;

      vertIndices[0][1] = 0;

      vertIndices[0][2] = 1;

      vertIndices[3][0] = 2;

      vertIndices[3][1] = 0;

      vertIndices[3][2] = 1;

      vertIndices[1][0] = 3;

      vertIndices[1][1] = 0;

      vertIndices[1][2] = 2;

      vertIndices[4][0] = 3;

      vertIndices[4][1] = 0;

      vertIndices[4][2] = 2;

      vertIndices[2][0] = 1;

      vertIndices[2][1] = 0;

      vertIndices[2][2] = 3;

      vertIndices[5][0] = 1;

      vertIndices[5][1] = 0;

      vertIndices[5][2] = 3;

      int N1 = 4;

      int N2 = N1 + IVY_N + 1;

      int N3 = N2 + IVY_N + 1;

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

        {

        double cos1 = Math.cos((IVY_N-i)*angle);

        double sin1 = Math.sin((IVY_N-i)*angle);

        double cos2 = Math.cos((      i)*angle);

        double sin2 = Math.sin((      i)*angle);

        vertices[N1+i][0] = CORR*(cos1-0.5) - 0.5;

        vertices[N1+i][1] = CORR*(sin1-0.5) - 0.5;

        vertices[N1+i][2] = 0.0;

        vertices[N2+i][0] = 0.0;

        vertices[N2+i][1] = CORR*(sin2-0.5) - 0.5;

        vertices[N2+i][2] = CORR*(cos2-0.5) - 0.5;

        vertices[N3+i][0] = CORR*(cos2-0.5) - 0.5;

        vertices[N3+i][1] = 0.0;

        vertices[N3+i][2] = CORR*(sin2-0.5) - 0.5;

        vertIndices[0][i+3] = N1 + i;

        vertIndices[1][i+3] = N2 + i;

        vertIndices[2][i+3] = N3 + i;

        vertIndices[3][i+3] = N1 + i;

        vertIndices[4][i+3] = N2 + i;

        vertIndices[5][i+3] = N3 + i;

        }

      float C = 0.5f - SQ2/4;

      float[] convexCenter = new float[] {-C,-C,-C};

      return new ObjectShape(vertices,vertIndices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), convexCenter);

      }

    else

      {

      final float angle = (float)Math.PI/(2*IVY_N);

      final float CORR  = 1.0f - 2*IVY_D;

      double[][] vertices = new double[2*IVY_N][3];

      int[][] vert_indices = new int[2][2*IVY_N];

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

      int[] indexes    = new int[2*IVY_N];

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

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

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

        {

        double sin = Math.sin(i*angle);

        double cos = Math.cos(i*angle);

        vertices[i      ][0] = CORR*(0.5f-cos);

        vertices[i      ][1] = CORR*(0.5f-sin);

        vertices[i      ][2] = 0;

        vertices[i+IVY_N][0] = CORR*(cos-0.5f);

        vertices[i+IVY_N][1] = CORR*(sin-0.5f);

        vertices[i+IVY_N][2] = 0;

        }

      for(int i=0; i<2*IVY_N; i++)

        {

        vert_indices[0][i] = i;

        vert_indices[1][i] = 2*IVY_N-1-i;

        }

      for(int i=0; i<2*IVY_N; i++)

        {

        indexes[i] = -1;

        }

      indexes[0] = indexes[IVY_N] = 0;

      float[][] bands =

        {

          {+0.03f,35,0.5f,0.5f,5,0,0},

          {+0.10f,45,0.5f,0.0f,2,0,0}

        };

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

      }

    }

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

  Static4D getQuat(int cubit, int numLayers)

    {

    if( mQuats==null ) initializeQuats();

    switch(cubit)

      {

      case  0: return mQuats[0];

      case  1: return mQuats[2];

      case  2: return mQuats[3];

      case  3: return mQuats[1];

      case  4: return mQuats[8];

      case  5: return mQuats[11];

      case  6: return mQuats[10];

      case  7: return mQuats[9];

      case  8: return mQuats[0];

      case  9: return mQuats[2];

      }

    return mQuats[0];

    }

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

  int getNumCubitVariants(int numLayers)

    {

    return 2;

    }

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

  int getCubitVariant(int cubit, int numLayers)

    {

    return cubit<4 ? 0:1;

    }

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

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

    {

    if( mFaceMap==null )

      {

      mFaceMap = new int[][]

         {

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

           {  5, 1, 2, 12,12,12 },

           {  4, 1, 3, 12,12,12 },

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

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

           {  7, 12,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];

    }

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

  int getColor(int face)

    {

    return FACE_COLORS[face];

    }

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

  ObjectSticker retSticker(int face)

    {

    if( mStickers==null )

      {

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

      mStickers = new ObjectSticker[NUM_STICKERS];

      float D = (float)(Math.PI/4);

      final float[][] angles = { { 0,0,D },{ D,D } };

      final float[][] radii  = { { 0,0.04f,0 },{ 0.06f,0.06f } };

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

      for(int s=0; s<NUM_STICKERS; s++) mStickers[s] = new ObjectSticker(STICKERS[s], angles[s],radii[s],strokes[s]);

      }

    return mStickers[face/NUM_FACES];

    }

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

  float returnMultiplier()

    {

    return 2.0f;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[] getBasicAngle()

    {

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

    return mBasicAngle;

    }

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

  public int getObjectName(int numLayers)

    {

    return R.string.ivy2;

    }

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

  public int getInventor(int numLayers)

    {

    return R.string.ivy2_inventor;

    }

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

  public int getComplexity(int numLayers)

    {

    return 1;

    }

}