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.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 org.distorted.main.RubikActivity;

import java.lang.reflect.Field;

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

public enum RubikObjectList

  {

  CUBE (

         new int[][] {

                       {2 , 12, R.raw.cube2, R.drawable.ui_small_cube2, R.drawable.ui_medium_cube2, R.drawable.ui_big_cube2, R.drawable.ui_huge_cube2} ,

                       {3 , 16, R.raw.cube3, R.drawable.ui_small_cube3, R.drawable.ui_medium_cube3, R.drawable.ui_big_cube3, R.drawable.ui_huge_cube3} ,

                       {4 , 20, R.raw.cube4, R.drawable.ui_small_cube4, R.drawable.ui_medium_cube4, R.drawable.ui_big_cube4, R.drawable.ui_huge_cube4} ,

                       {5 , 24, R.raw.cube5, R.drawable.ui_small_cube5, R.drawable.ui_medium_cube5, R.drawable.ui_big_cube5, R.drawable.ui_huge_cube5}

                     },

         RubikCube.class,

         new RubikMovementCube(),

         0

       ),

  PYRA (

         new int[][] {

                       {3 , 10, R.raw.pyra3, R.drawable.ui_small_pyra3, R.drawable.ui_medium_pyra3, R.drawable.ui_big_pyra3, R.drawable.ui_huge_pyra3} ,

                       {4 , 15, R.raw.pyra4, R.drawable.ui_small_pyra4, R.drawable.ui_medium_pyra4, R.drawable.ui_big_pyra4, R.drawable.ui_huge_pyra4} ,

                       {5 , 20, R.raw.pyra5, R.drawable.ui_small_pyra5, R.drawable.ui_medium_pyra5, R.drawable.ui_big_pyra5, R.drawable.ui_huge_pyra5}

                     },

         RubikPyraminx.class,

         new RubikMovementPyraminx(),

         1

       ),

  DINO (

         new int[][] {

                       {3 , 10, R.raw.dino, R.drawable.ui_small_dino, R.drawable.ui_medium_dino, R.drawable.ui_big_dino, R.drawable.ui_huge_dino} ,

                     },

         RubikDino.class,

         new RubikMovementDino(),

         2

       ),

  ;

  public static final int NUM_OBJECTS = values().length;

  public static final int MAX_NUM_OBJECTS;

  public static final int MAX_LEVEL;

  public static final int MAX_OBJECT_SIZE;

  private final int[] mObjectSizes, mMaxLevels, mSmallIconIDs, mMediumIconIDs, mBigIconIDs, mHugeIconIDs, mResourceIDs;

  private final Class<? extends RubikObject> mObjectClass;

  private final RubikMovement mObjectMovementClass;

  private final int mColumn, mNumSizes;

  private static final RubikObjectList[] objects;

  private static int mNumAll;

  private static int[] mIndices;

  private static int mColCount, mRowCount;

  static

    {

    mNumAll = 0;

    int num, i = 0;

    objects = new RubikObjectList[NUM_OBJECTS];

    int maxNum  = Integer.MIN_VALUE;

    int maxLevel= Integer.MIN_VALUE;

    int maxSize = Integer.MIN_VALUE;

    for(RubikObjectList object: RubikObjectList.values())

      {

      objects[i] = object;

      i++;

      num = object.mObjectSizes.length;

      mNumAll += num;

      if( num> maxNum ) maxNum = num;

      for(int j=0; j<num; j++)

        {

        if( object.mMaxLevels[j] > maxLevel ) maxLevel = object.mMaxLevels[j];

        if( object.mObjectSizes[j] > maxSize) maxSize  = object.mObjectSizes[j];

        }

      }

    MAX_NUM_OBJECTS = maxNum;

    MAX_LEVEL       = maxLevel;

    MAX_OBJECT_SIZE = maxSize;

    }

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

  private static void setUpColAndRow()

    {

    mIndices = new int[NUM_OBJECTS];

    mColCount= 0;

    for(int obj=0; obj<NUM_OBJECTS; obj++)

      {

      mIndices[obj] = objects[obj].mColumn;

      if( mIndices[obj]>=mColCount ) mColCount = mIndices[obj]+1;

      }

    mRowCount = 0;

    for(int col=0; col<mColCount; col++)

      {

      int numObjects = computeNumObjectsInColumn(col);

      if( numObjects>mRowCount ) mRowCount = numObjects;

      }

    }

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

  private static int computeNumObjectsInColumn(int column)

    {

    int num=0;

    for(int object=0; object<NUM_OBJECTS; object++)

      {

      if( objects[object].mColumn == column )

        {

        num += objects[object].mNumSizes;

        }

      }

    return num;

    }

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

  public static int getColumnCount()

    {

    if( mIndices==null ) setUpColAndRow();

    return mColCount;

    }

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

  public static int getRowCount()

    {

    if( mIndices==null ) setUpColAndRow();

    return mRowCount;

    }

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

  public static int[] getIndices()

    {

    if( mIndices==null ) setUpColAndRow();

    return mIndices;

    }

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

  public static RubikObjectList getObject(int ordinal)

    {

    return ordinal>=0 && ordinal<NUM_OBJECTS ? objects[ordinal] : CUBE;

    }

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

  public static int pack(int object, int sizeIndex)

    {

    int ret = 0;

    for(int i=0; i<object; i++) ret += objects[i].mObjectSizes.length;

    return ret+sizeIndex;

    }

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

  public static int unpackSizeIndex(int number)

    {

    int num;

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

      {

      num = objects[i].mObjectSizes.length;

      if( number<num ) return number;

      number -= num;

      }

    return -1;

    }

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

  public static int unpackObject(int number)

    {

    int num;

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

      {

      num = objects[i].mObjectSizes.length;

      if( number<num ) return i;

      number -= num;

      }

    return -1;

    }

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

  public static int unpackObjectFromString(String obj)

    {

    int u = obj.indexOf('_');

    int l = obj.length();

    if( u>0 )

      {

      String name = obj.substring(0,u);

      int size = Integer.parseInt( obj.substring(u+1,l) );

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

        {

        if( objects[i].name().equals(name) )

          {

          int sizeIndex = getSizeIndex(i,size);

          return pack(i,sizeIndex);

          }

        }

      }

    return -1;

    }

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

  public static String getObjectList()

    {

    String name;

    StringBuilder list = new StringBuilder();

    int len;

    int[] sizes;

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

      {

      sizes = objects[i].mObjectSizes;

      len   = sizes.length;

      name  = objects[i].name();

      for(int j=0; j<len; j++)

        {

        if( i>0 || j>0 ) list.append(',');

        list.append(name);

        list.append('_');

        list.append(sizes[j]);

        }

      }

    return list.toString();

    }

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

  public static int getTotal()

    {

    return mNumAll;

    }

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

  public static int getMaxLevel(int ordinal, int sizeIndex)

    {

    if( ordinal>=0 && ordinal<NUM_OBJECTS )

      {

      int num = objects[ordinal].mObjectSizes.length;

      return sizeIndex>=0 && sizeIndex<num ? objects[ordinal].mMaxLevels[sizeIndex] : 0;

      }

    return 0;

    }

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

  public static int getOrdinal(String name)

    {

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

      {

      if(objects[i].name().equals(name)) return i;

      }

    return -1;

    }

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

  public static int getSizeIndex(int ordinal, int size)

    {

    if( ordinal>=0 && ordinal<NUM_OBJECTS )

      {

      int[] sizes = objects[ordinal].getSizes();

      int len = sizes.length;

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

        {

        if( sizes[i]==size ) return i;

        }

      }

    return -1;

    }

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

  public static int[] retFaceColors(RubikObjectList object)

    {

    Field field;

    int[] faceColors=null;

    try

      {

      field = object.mObjectClass.getDeclaredField("FACE_COLORS");

      field.setAccessible(true);

      Object obj = field.get(null);

      faceColors = (int[]) obj;

      }

    catch(NoSuchFieldException ex)

      {

      android.util.Log.e("RubikObjectList", object.mObjectClass.getSimpleName()+": no such field exception getting field: "+ex.getMessage());

      }

    catch(IllegalAccessException ex)

      {

      android.util.Log.e("RubikObjectList", object.mObjectClass.getSimpleName()+": illegal access exception getting field: "+ex.getMessage());

      }

    return faceColors;

    }

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

  RubikObjectList(int[][] info, Class<? extends RubikObject> object , RubikMovement movement, int column)

    {

    mNumSizes = info.length;

    mObjectSizes  = new int[mNumSizes];

    mMaxLevels    = new int[mNumSizes];

    mResourceIDs  = new int[mNumSizes];

    mSmallIconIDs = new int[mNumSizes];

    mMediumIconIDs= new int[mNumSizes];

    mBigIconIDs   = new int[mNumSizes];

    mHugeIconIDs  = new int[mNumSizes];

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

      {

      mObjectSizes[i]  = info[i][0];

      mMaxLevels[i]    = info[i][1];

      mResourceIDs[i]  = info[i][2];

      mSmallIconIDs[i] = info[i][3];

      mMediumIconIDs[i]= info[i][4];

      mBigIconIDs[i]   = info[i][5];

      mHugeIconIDs[i]  = info[i][6];

      }

    mObjectClass         = object;

    mObjectMovementClass = movement;

    mColumn              = column;

    }

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

  public int[] getSizes()

    {

    return mObjectSizes;

    }

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

  public int[] getMaxLevels()

    {

    return mMaxLevels;

    }

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

  public int[] getIconIDs()

    {

    int size = RubikActivity.getDrawableSize();

    switch(size)

      {

      case 0 : return mSmallIconIDs;

      case 1 : return mMediumIconIDs;

      case 2 : return mBigIconIDs;

      default: return mHugeIconIDs;

      }

    }

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

  public int[] getResourceIDs()

    {

    return mResourceIDs;

    }

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

  public int getNumVariants()

    {

    return mObjectSizes.length;

    }

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

  public RubikObject create(int size, Static4D quat, int[][] moves, Resources res, int scrWidth)

    {

    DistortedTexture texture = new DistortedTexture();

    DistortedEffects effects = new DistortedEffects();

    MeshSquare mesh      = new MeshSquare(20,20);   // mesh of the node, not of the cubits

    switch(ordinal())

      {

      case 0: return new RubikCube    (size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 1: return new RubikPyraminx(size, quat, texture, mesh, effects, moves, res, scrWidth);

      case 2: return new RubikDino    (size, quat, texture, mesh, effects, moves, res, scrWidth);

      }

    return null;

    }

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

  public RubikMovement getObjectMovementClass()

    {

    return mObjectMovementClass;

    }

  }