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.library.main.DistortedTexture;

import org.distorted.library.type.Static4D;

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

           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)

         };

         {

           COLOR_BLUE  , COLOR_GREEN,

  // All legal rotation quats of a RubikDino

           new Static4D(  0.0f,  0.0f,  0.0f,  1.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(  1.0f,  0.0f,  0.0f,  0.0f ),

           new Static4D(  0.5f,  0.5f, -0.5f,  0.5f )

  // centers of the 12 edges. Must be in the same order like QUATs above.

             { 1.5f, 0.0f, 1.5f },

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

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

             { 1.5f, 1.5f, 0.0f },

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

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

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

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

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

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

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

             { 1.5, 0.0, 0.0},

             { 0.0,-1.5, 0.0},

             { 0.0, 0.0,-1.5}

             {2,1,0},   // counterclockwise!

             {3,2,0},

          };

          {

             { 0.0f, -1.0f/3, 0.5f, 1.0f/6, -0.5f, 1.0f/6 }

          };

  static

    {

    float radius = 0.025f;

    float stroke = 0.050f;

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

    mStickers = new ObjectSticker[STICKERS.length];

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

    }

  private int mIndexExcluded;

  private int[][] mScrambleTable;

  private int[] mNumOccurences;

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

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

  float getScreenRatio()

    {

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

  Static4D[] getQuats()

    {

    return QUATS;

    }

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

  int getNumFaces()

    {

    return FACE_COLORS.length;

    }

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

    }

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

    return CENTERS;

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

    float[][] corners   = new float[][] { {0.07f,0.40f}, {0.05f,0.30f} };

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

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

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

    return new ObjectShape(VERTICES,VERT_INDEXES,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);

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

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

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

    }

  ObjectSticker retSticker(int face)

    {

    return mStickers[face/NUM_FACES];

  float returnMultiplier()

    {

    return 2.0f;

    }

  private void initializeScrambling()

    {

    int numLayers = getNumLayers();

    if( mScrambleTable ==null )

      {

      mScrambleTable = new int[NUM_AXIS][numLayers];

      }

    if( mNumOccurences ==null )

      {

      int max=0;

      for (ScrambleState mState : mStates)

        {

        int tmp = mState.getTotal(-1);

        if (max < tmp) max = tmp;

        }

      mNumOccurences = new int[max];

      }

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

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

    }

// PUBLIC API

    {

    if( curr==0 )

      {

      mCurrState     = 0;

      mIndexExcluded =-1;

    scramble[curr][0] = info[0];

    scramble[curr][1] = info[1];

    scramble[curr][2] = info[2];

    mCurrState     = info[3];

    mIndexExcluded = info[0];

    }

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

    {

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

  public int getComplexity(int numLayers)

    {

    return 2;

    }