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.object;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedTexture;

import org.distorted.magic.R;

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

public enum RubikObjectList

  {

             new int[] {R.drawable.cube2,R.drawable.cube3,R.drawable.cube4},

             new RubikCubeMovement() ),

  PYRAMINX ( new int[] {3,4},

             new int[] {R.drawable.pyra3,R.drawable.pyra4},

             new RubikPyraminxMovement() ),

  public static final int MAX_SIZE;

  private final int[] mObjectSizes, mIconIDs;

  final RubikObjectMovement mObjectMovementClass;

  static

    {

    int size, i = 0;

    objects = new RubikObjectList[NUM_OBJECTS];

    int maxsize = Integer.MIN_VALUE;

      mNumAll += size;

      if( size> maxsize ) maxsize = size;

    MAX_SIZE = maxsize;

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

  public static RubikObjectList getObject(int ordinal)

    {

    return objects[ordinal];

    }

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

    {

    int ret = 0;

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

    return ret+size;

    }

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

  public static int unpackSize(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)

    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 s = getSize(i,size);

          return pack(i,s);

          }

        }

      }

    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 getOrdinal(String name)

    {

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

      {

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

      }

    return -1;

    }

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

  public static int getSize(int ordinal, int size)

    {

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

    int len = sizes.length;

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

      {

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

      }

    return -1;

    }

  RubikObjectList(int[] sizes, int[] iconIDs, RubikObjectMovement movement)

    {

    mObjectSizes= sizes;

    mIconIDs    = iconIDs;

    }

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

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

    {

    return mObjectSizes;

    }

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

  public RubikObject create(int size, Static4D quatCur, Static4D quatAcc)

      {

      case 0: return new RubikCube    (size, quatCur, quatAcc, texture, mesh, effects);

      case 1: return new RubikPyraminx(size, quatCur, quatAcc, texture, mesh, effects);

      }

    return null;

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

  public RubikObjectMovement getObjectMovementClass()

    {

  }