commit 7ac0ee8811d6d0fd97cfc3e718f09c8655780b45
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Fri Oct 1 16:31:41 2021 +0200

    Simplify ObjectList: now there's just one object per size.

diff --git a/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java b/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java
index 938f2745..3c4a49e5 100644
--- a/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java
+++ b/src/main/java/org/distorted/dialogs/RubikDialogNewRecord.java
@@ -82,10 +82,8 @@ public class RubikDialogNewRecord extends AppCompatDialogFragment
           {
           RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();
           int object = play.getObject();
-          int size   = play.getSize();
-          int sizeIndex = ObjectList.getSizeIndex(object,size);
 
-          bundle.putInt("tab", ObjectList.pack(object,sizeIndex) );
+          bundle.putInt("tab", object );
           bundle.putBoolean("submitting", true);
 
           RubikDialogScores scoresDiag = new RubikDialogScores();
diff --git a/src/main/java/org/distorted/dialogs/RubikDialogPattern.java b/src/main/java/org/distorted/dialogs/RubikDialogPattern.java
index d9a51af5..ebcc20fd 100644
--- a/src/main/java/org/distorted/dialogs/RubikDialogPattern.java
+++ b/src/main/java/org/distorted/dialogs/RubikDialogPattern.java
@@ -105,10 +105,8 @@ public class RubikDialogPattern extends AppCompatDialogFragment
     for(int i=0; i< RubikPatternList.NUM_OBJECTS; i++)
       {
       ObjectList list = RubikPatternList.getObject(i);
-      int size        = RubikPatternList.getSize(i);
-      int sizeIndex   = ObjectList.getSizeIndex(list.ordinal(),size);
       int iconSize    = RubikActivity.getDrawableSize();
-      int iconID      = list.getIconIDs(iconSize)[sizeIndex];
+      int iconID      = list.getIconID(iconSize);
 
       ImageView imageView = new ImageView(act);
       imageView.setImageResource(iconID);
diff --git a/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java b/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java
index 98aaa5e0..d5d5e224 100644
--- a/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java
+++ b/src/main/java/org/distorted/dialogs/RubikDialogPatternView.java
@@ -95,9 +95,8 @@ public class RubikDialogPatternView extends FrameLayout
         RubikPattern pattern = RubikPattern.getInstance();
         int[][] moves   = pattern.reInitialize(mTab, groupPosition, childPosition);
         ObjectList list = RubikPatternList.getObject(mTab);
-        int size        = RubikPatternList.getSize(mTab);
 
-        ract.setupObject(list, size, moves);
+        ract.setupObject(list, moves);
 
         ScreenList.switchScreen(ract, ScreenList.PATT);
         RubikScreenPattern state = (RubikScreenPattern) ScreenList.PATT.getScreenClass();
diff --git a/src/main/java/org/distorted/dialogs/RubikDialogScores.java b/src/main/java/org/distorted/dialogs/RubikDialogScores.java
index 9e00c0c1..769480ae 100644
--- a/src/main/java/org/distorted/dialogs/RubikDialogScores.java
+++ b/src/main/java/org/distorted/dialogs/RubikDialogScores.java
@@ -105,22 +105,16 @@ public class RubikDialogScores extends AppCompatDialogFragment
 
     viewPager.setCurrentItem(curTab);
     ObjectList list;
+    int iconSize = RubikActivity.getDrawableSize();
 
     for (int object = 0; object< ObjectList.NUM_OBJECTS; object++)
       {
       list = ObjectList.getObject(object);
-      int iconSize = RubikActivity.getDrawableSize();
-      int[] iconID = list.getIconIDs(iconSize);
-      int len = list.getSizes().length;
-
-      for(int size=0; size<len; size++)
-        {
-        int t = ObjectList.pack(object,size);
-        ImageView imageView = new ImageView(act);
-        imageView.setImageResource(iconID[size]);
-        TabLayout.Tab tab = tabLayout.getTabAt(t);
-        if(tab!=null) tab.setCustomView(imageView);
-        }
+      int iconID = list.getIconID(iconSize);
+      ImageView imageView = new ImageView(act);
+      imageView.setImageResource(iconID);
+      TabLayout.Tab tab = tabLayout.getTabAt(object);
+      if(tab!=null) tab.setCustomView(imageView);
       }
 
     Dialog dialog = builder.create();
diff --git a/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java b/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java
index bb65bfd4..63bc78bc 100644
--- a/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java
+++ b/src/main/java/org/distorted/dialogs/RubikDialogScoresPagerAdapter.java
@@ -117,11 +117,9 @@ class RubikDialogScoresPagerAdapter extends PagerAdapter implements RubikNetwork
 
     for(int i=0; i<mNumTabs; i++)
       {
-      int object   = ObjectList.unpackObject(i);
-      int sizeIndex= ObjectList.unpackSizeIndex(i);
-      lastTab[i]   = ObjectList.getDBLevel(object, sizeIndex);
-      maxTab[i]    = Math.min(lastTab[i],MAX);
-      toDoTab[i]   = 0;
+      lastTab[i]= ObjectList.getDBLevel(i);
+      maxTab[i] = Math.min(lastTab[i],MAX);
+      toDoTab[i]= 0;
 
       toDo += maxTab[i];
       }
@@ -210,7 +208,7 @@ class RubikDialogScoresPagerAdapter extends PagerAdapter implements RubikNetwork
     {
     mAct = act;
     mDialog = diag;
-    mNumTabs = ObjectList.getTotal();
+    mNumTabs = ObjectList.NUM_OBJECTS;
     mViews = new RubikDialogScoresView[mNumTabs];
     mViewPager = viewPager;
     mIsSubmitting = isSubmitting;
diff --git a/src/main/java/org/distorted/dialogs/RubikDialogScoresView.java b/src/main/java/org/distorted/dialogs/RubikDialogScoresView.java
index f3a53e08..3fa5e30c 100644
--- a/src/main/java/org/distorted/dialogs/RubikDialogScoresView.java
+++ b/src/main/java/org/distorted/dialogs/RubikDialogScoresView.java
@@ -88,13 +88,10 @@ public class RubikDialogScoresView extends FrameLayout
 
     Resources res = act.getResources();
     String packageName = act.getPackageName();
-
-    int object   = ObjectList.unpackObject(tab);
-    int sizeIndex= ObjectList.unpackSizeIndex(tab);
     RubikScores scores = RubikScores.getInstance();
 
     boolean inserted = false;
-    long myRecordInMillis = scores.getRecord(object, sizeIndex, level);
+    long myRecordInMillis = scores.getRecord(tab, level);
     float myRecordInSeconds = (myRecordInMillis/10)/100.0f;
     String myName = scores.getName();
     if( myName.length()==0 ) myName = act.getString(R.string.you);
diff --git a/src/main/java/org/distorted/dialogs/RubikDialogSetName.java b/src/main/java/org/distorted/dialogs/RubikDialogSetName.java
index 5ab56b2f..c1c1cd8e 100644
--- a/src/main/java/org/distorted/dialogs/RubikDialogSetName.java
+++ b/src/main/java/org/distorted/dialogs/RubikDialogSetName.java
@@ -149,12 +149,8 @@ public class RubikDialogSetName extends AppCompatDialogFragment
           RubikScores.getInstance().setName(name);
           RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();
 
-          int object = play.getObject();
-          int size   = play.getSize();
-          int sizeIndex = ObjectList.getSizeIndex(object,size);
-
           Bundle bundle = new Bundle();
-          bundle.putInt("tab", ObjectList.pack(object,sizeIndex) );
+          bundle.putInt("tab", play.getObject() );
           bundle.putBoolean("submitting", true);
 
           RubikDialogScores scores = new RubikDialogScores();
diff --git a/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java b/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java
index 51f61785..f3b9eb8c 100644
--- a/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java
+++ b/src/main/java/org/distorted/dialogs/RubikDialogTutorialView.java
@@ -77,7 +77,6 @@ public class RubikDialogTutorialView extends FrameLayout
 
     TutorialList list  = TutorialList.getObject(position);
     ObjectList objList = list.getObjectList();
-    int size           = list.getSize();
 
     View tab = inflate( act, R.layout.dialog_tutorial_tab, null);
     LinearLayout layout = tab.findViewById(R.id.tabLayout);
@@ -93,7 +92,7 @@ public class RubikDialogTutorialView extends FrameLayout
 
       int countryID = res.getIdentifier( coun, "drawable", packageName);
 
-      View row = createRow(ract,countryID,desc,url,auth,widthT,objList,size);
+      View row = createRow(ract,countryID,desc,url,auth,widthT,objList);
       layout.addView(row);
       }
 
@@ -110,7 +109,7 @@ public class RubikDialogTutorialView extends FrameLayout
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   private View createRow(final RubikActivity act, int countryID, final String desc, final String url,
-                         final String auth, int width, final ObjectList obj, final int size)
+                         final String auth, int width, final ObjectList obj)
     {
     View row = inflate( act, R.layout.dialog_tutorial_row, null);
     Button butt = row.findViewById(R.id.tutorialButton);
@@ -126,8 +125,8 @@ public class RubikDialogTutorialView extends FrameLayout
         {
         if( mCanClick )
           {
-          act.switchTutorial(url,obj,size);
-          analyticsReport(act,desc,auth,obj,size);
+          act.switchTutorial(url,obj);
+          analyticsReport(act,desc,auth,obj);
           clickPossible(false);
           }
         }
@@ -150,7 +149,7 @@ public class RubikDialogTutorialView extends FrameLayout
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private void analyticsReport(RubikActivity act, String desc, String author, ObjectList obj, int size)
+  private void analyticsReport(RubikActivity act, String desc, String author, ObjectList obj)
     {
     String message = desc+" ("+author+")";
 
@@ -161,13 +160,12 @@ public class RubikDialogTutorialView extends FrameLayout
     else
       {
       FirebaseAnalytics analytics = act.getAnalytics();
-      String name = obj.name()+"_"+size;
 
       if( analytics!=null )
         {
         Bundle bundle = new Bundle();
         bundle.putString(FirebaseAnalytics.Param.CONTENT_TYPE, message);
-        bundle.putString(FirebaseAnalytics.Param.ITEM_NAME, name);
+        bundle.putString(FirebaseAnalytics.Param.ITEM_NAME, obj.name());
         analytics.logEvent(FirebaseAnalytics.Event.TUTORIAL_BEGIN, bundle);
         }
       }
diff --git a/src/main/java/org/distorted/main/RubikActivity.java b/src/main/java/org/distorted/main/RubikActivity.java
index 471a0304..a997816b 100644
--- a/src/main/java/org/distorted/main/RubikActivity.java
+++ b/src/main/java/org/distorted/main/RubikActivity.java
@@ -276,28 +276,19 @@ public class RubikActivity extends TwistyActivity
       boolean success = false;
       RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();
       int object = play.getObject();
-      int size   = play.getSize();
 
       if( object>=0 && object< ObjectList.NUM_OBJECTS )
         {
-        ObjectList obj = ObjectList.getObject(object);
-        int[] sizes = obj.getSizes();
-        int sizeIndex = ObjectList.getSizeIndex(object,size);
-
-        if( sizeIndex>=0 && sizeIndex<sizes.length )
-          {
-          success = true;
-          view.getPreRender().changeObject(obj,size);
-          }
+        success = true;
+        ObjectList nextObj = ObjectList.values()[object];
+        view.getPreRender().changeObject(nextObj);
         }
 
       if( !success )
         {
         ObjectList obj = ObjectList.getObject(RubikScreenPlay.DEF_OBJECT);
-        int s = RubikScreenPlay.DEF_SIZE;
-
-        play.setObjectAndSize(this,obj,s);
-        view.getPreRender().changeObject(obj,s);
+        play.setObject(this,obj);
+        view.getPreRender().changeObject(obj);
         }
 
       if( mIsChinese && !mPolicyAccepted ) PrivacyPolicy();
@@ -466,7 +457,7 @@ public class RubikActivity extends TwistyActivity
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-    public void changeObject(ObjectList newObject, int newSize, boolean reportChange)
+    public void changeObject(ObjectList newObject, boolean reportChange)
       {
       RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);
       RubikPreRender pre = view.getPreRender();
@@ -478,19 +469,14 @@ public class RubikActivity extends TwistyActivity
         if( oldObject!=null )
           {
           ObjectList oldList = oldObject.getObjectList();
-          int oldNum = oldObject.getNumLayers();
           float fps = view.getRenderer().getFPS();
           fps = (int)(fps+0.5f);
           StringBuilder name = new StringBuilder();
           name.append(oldList.name());
-          name.append('_');
-          name.append(oldNum);
           name.append(' ');
           name.append(fps);
           name.append(" --> ");
           name.append(newObject.name());
-          name.append('_');
-          name.append(newSize);
 
           if( BuildConfig.DEBUG )
             {
@@ -510,16 +496,16 @@ public class RubikActivity extends TwistyActivity
           }
         }
 
-      pre.changeObject(newObject,newSize);
+      pre.changeObject(newObject);
       }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-    public void setupObject(ObjectList object, int size, int[][] moves)
+    public void setupObject(ObjectList object, int[][] moves)
       {
       RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);
       RubikPreRender pre = view.getPreRender();
-      pre.setupObject(object,size,moves);
+      pre.setupObject(object,moves);
       }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -642,12 +628,11 @@ public class RubikActivity extends TwistyActivity
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-    public void switchTutorial(String url, ObjectList object, int size)
+    public void switchTutorial(String url, ObjectList object)
       {
       Intent myIntent = new Intent(this, TutorialActivity.class);
       myIntent.putExtra("url", url);
       myIntent.putExtra("obj", object.ordinal());
-      myIntent.putExtra("siz", size);
       startActivity(myIntent);
       }
 }
diff --git a/src/main/java/org/distorted/main/RubikPreRender.java b/src/main/java/org/distorted/main/RubikPreRender.java
index 72dea455..42d8d7fb 100644
--- a/src/main/java/org/distorted/main/RubikPreRender.java
+++ b/src/main/java/org/distorted/main/RubikPreRender.java
@@ -61,7 +61,6 @@ public class RubikPreRender implements EffectController, TwistyPreRender
   private boolean mUIBlocked, mTouchBlocked;
   private boolean mIsSolved;
   private ObjectList mNextObject;
-  private int mNextSize;
   private long mRotationFinishedID;
   private final long[] mEffectID;
   private boolean mIsNewRecord;
@@ -115,7 +114,7 @@ public class RubikPreRender implements EffectController, TwistyPreRender
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private void createObjectNow(ObjectList object, int size, int[][] moves)
+  private void createObjectNow(ObjectList object, int[][] moves)
     {
     boolean firstTime = (mNewObject==null);
 
@@ -125,7 +124,7 @@ public class RubikPreRender implements EffectController, TwistyPreRender
     Context con = mView.getContext();
     Resources res = con.getResources();
 
-    mNewObject = object.create(size, mView.getQuat(), moves, res, mScreenWidth);
+    mNewObject = object.create(mView.getQuat(), moves, res, mScreenWidth);
 
     if( mNewObject!=null )
       {
@@ -248,10 +247,10 @@ public class RubikPreRender implements EffectController, TwistyPreRender
     {
     mChangeObject = false;
 
-    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getNumLayers()!=mNextSize)
+    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject )
       {
       blockEverything(BlockController.RUBIK_PLACE_1);
-      createObjectNow(mNextObject, mNextSize, null);
+      createObjectNow(mNextObject, null);
       doEffectNow( BaseEffect.Type.SIZECHANGE );
       }
     }
@@ -262,10 +261,10 @@ public class RubikPreRender implements EffectController, TwistyPreRender
     {
     mSetupObject = false;
 
-    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getNumLayers()!=mNextSize)
+    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject)
       {
       blockEverything(BlockController.RUBIK_PLACE_2);
-      createObjectNow(mNextObject, mNextSize, mNextMoves);
+      createObjectNow(mNextObject, mNextMoves);
       doEffectNow( BaseEffect.Type.SIZECHANGE );
       }
     else
@@ -344,12 +343,11 @@ public class RubikPreRender implements EffectController, TwistyPreRender
     RubikScores scores = RubikScores.getInstance();
 
     int object      = play.getObject();
-    int size        = play.getSize();
     int level       = play.getLevel();
     ObjectList list = ObjectList.getObject(object);
     String name     = scores.getName();
 
-    String record = list.name()+"_"+size+" level "+level+" time "+mNewRecord+" isNew: "+mIsNewRecord+" scrambleNum: "+mScrambleObjectNum;
+    String record = list.name()+" level "+level+" time "+mNewRecord+" isNew: "+mIsNewRecord+" scrambleNum: "+mScrambleObjectNum;
 
     if( BuildConfig.DEBUG )
        {
@@ -499,27 +497,19 @@ public class RubikPreRender implements EffectController, TwistyPreRender
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  void changeObject(ObjectList object, int size)
+  void changeObject(ObjectList object)
     {
-    if( size>0 )
-      {
-      mChangeObject = true;
-      mNextObject = object;
-      mNextSize   = size;
-      }
+    mChangeObject = true;
+    mNextObject = object;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  void setupObject(ObjectList object, int size, int[][] moves)
+  void setupObject(ObjectList object, int[][] moves)
     {
-    if( size>0 )
-      {
-      mSetupObject= true;
-      mNextObject = object;
-      mNextSize   = size;
-      mNextMoves  = moves;
-      }
+    mSetupObject= true;
+    mNextObject = object;
+    mNextMoves  = moves;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/main/RubikSurfaceView.java b/src/main/java/org/distorted/main/RubikSurfaceView.java
index edb0d7bf..e3d12547 100644
--- a/src/main/java/org/distorted/main/RubikSurfaceView.java
+++ b/src/main/java/org/distorted/main/RubikSurfaceView.java
@@ -257,7 +257,7 @@ public class RubikSurfaceView extends GLSurfaceView
               int color = solver.getCurrentColor();
               mLastCubit = object.getCubit(point);
               mPreRender.setTextureMap( mLastCubit, mLastCubitFace, color );
-              mLastCubitColor = SolverMain.cubitIsLocked(object.getObjectList(), object.getNumLayers(), mLastCubit);
+              mLastCubitColor = SolverMain.cubitIsLocked(object.getObjectList(), mLastCubit);
               }
             }
           }
diff --git a/src/main/java/org/distorted/network/RubikNetwork.java b/src/main/java/org/distorted/network/RubikNetwork.java
index ec092b03..1ab4e994 100644
--- a/src/main/java/org/distorted/network/RubikNetwork.java
+++ b/src/main/java/org/distorted/network/RubikNetwork.java
@@ -37,6 +37,7 @@ import org.distorted.library.main.DistortedLibrary;
 import org.distorted.objectlib.main.ObjectList;
 
 import static org.distorted.objectlib.main.ObjectList.MAX_LEVEL;
+import static org.distorted.objectlib.main.ObjectList.NUM_OBJECTS;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -96,7 +97,6 @@ public class RubikNetwork implements Runnable
     "%f8", "%f9", "%fa", "%fb", "%fc", "%fd", "%fe", "%ff"
     };
 
-  private static int mTotal = 0;
   private static String[][][] mCountry;
   private static String[][][] mName;
   private static float[][][] mTime;
@@ -113,11 +113,10 @@ public class RubikNetwork implements Runnable
 
   private static void initializeStatics()
     {
-    if( mTotal==0      ) mTotal   = ObjectList.getTotal();
-    if( mCountry==null ) mCountry = new String[mTotal][MAX_LEVEL][MAX_PLACES];
-    if( mName==null    ) mName    = new String[mTotal][MAX_LEVEL][MAX_PLACES];
-    if( mTime==null    ) mTime    = new  float[mTotal][MAX_LEVEL][MAX_PLACES];
-    if( mPlaces==null  ) mPlaces  = new int[mTotal][MAX_LEVEL];
+    if( mCountry==null ) mCountry = new String[NUM_OBJECTS][MAX_LEVEL][MAX_PLACES];
+    if( mName==null    ) mName    = new String[NUM_OBJECTS][MAX_LEVEL][MAX_PLACES];
+    if( mTime==null    ) mTime    = new  float[NUM_OBJECTS][MAX_LEVEL][MAX_PLACES];
+    if( mPlaces==null  ) mPlaces  = new int[NUM_OBJECTS][MAX_LEVEL];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -166,7 +165,7 @@ public class RubikNetwork implements Runnable
       return false;
       }
 
-    for(int i=0; i<mTotal; i++)
+    for(int i=0; i<NUM_OBJECTS; i++)
       for(int j=0; j<MAX_LEVEL; j++)
         {
         mPlaces[i][j] = 0;
@@ -205,9 +204,9 @@ public class RubikNetwork implements Runnable
 
     if( s5>s4 && s4>s3 && s3>s2 && s2>s1 && s1>0 )
       {
-      int object = ObjectList.unpackObjectFromString( row.substring(0,s1) );
+      int object = ObjectList.getOrdinal( row.substring(0,s1) );
 
-      if( object>=0 && object<mTotal )
+      if( object>=0 && object<NUM_OBJECTS )
         {
         int level      = Integer.parseInt( row.substring(s1+1,s2) );
         String name    = row.substring(s2+1, s3);
diff --git a/src/main/java/org/distorted/network/RubikScores.java b/src/main/java/org/distorted/network/RubikScores.java
index 0b07ef66..35754329 100644
--- a/src/main/java/org/distorted/network/RubikScores.java
+++ b/src/main/java/org/distorted/network/RubikScores.java
@@ -27,7 +27,6 @@ import android.telephony.TelephonyManager;
 
 import com.google.firebase.crashlytics.FirebaseCrashlytics;
 
-import static org.distorted.objectlib.main.ObjectList.MAX_NUM_OBJECTS;
 import static org.distorted.objectlib.main.ObjectList.NUM_OBJECTS;
 import static org.distorted.objectlib.main.ObjectList.MAX_LEVEL;
 
@@ -43,8 +42,8 @@ public class RubikScores
   public static final long NO_RECORD = Long.MAX_VALUE;
   private static RubikScores mThis;
 
-  private final long[][][] mRecords;
-  private final int [][][] mSubmitted;
+  private final long[][] mRecords;
+  private final int [][] mSubmitted;
 
   private String mName, mCountry;
   private boolean mNameIsVerified;
@@ -57,16 +56,15 @@ public class RubikScores
 
   private RubikScores()
     {
-    mRecords   = new long[NUM_OBJECTS][MAX_NUM_OBJECTS][MAX_LEVEL];
-    mSubmitted = new int [NUM_OBJECTS][MAX_NUM_OBJECTS][MAX_LEVEL];
+    mRecords   = new long[NUM_OBJECTS][MAX_LEVEL];
+    mSubmitted = new int [NUM_OBJECTS][MAX_LEVEL];
 
     for(int i=0; i<NUM_OBJECTS; i++)
-      for(int j=0; j<MAX_NUM_OBJECTS; j++)
-        for(int k=0; k<MAX_LEVEL; k++)
-          {
-          mRecords[i][j][k]   = NO_RECORD;
-          mSubmitted[i][j][k] = 0;
-          }
+      for(int j=0; j<MAX_LEVEL; j++)
+        {
+        mRecords[i][j]   = NO_RECORD;
+        mSubmitted[i][j] = 0;
+        }
 
     mName = "";
     mCountry = "un";
@@ -106,11 +104,10 @@ public class RubikScores
     mNameIsVerified = true;
 
     for(int i=0; i<NUM_OBJECTS; i++)
-      for(int j=0; j<MAX_NUM_OBJECTS; j++)
-        for(int k=0; k<MAX_LEVEL; k++)
-          {
-          mSubmitted[i][j][k]=1;
-          }
+      for(int j=0; j<MAX_LEVEL; j++)
+        {
+        mSubmitted[i][j]=1;
+        }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -124,22 +121,12 @@ public class RubikScores
 
   synchronized boolean thereAreUnsubmittedRecords()
     {
-    ObjectList list;
-    int length;
-
     for(int object=0; object<NUM_OBJECTS; object++)
       {
-      list = ObjectList.getObject(object);
-      length = list.getSizes().length;
-
-      for(int size=0; size<length; size++)
-        for(int level=0; level<MAX_LEVEL; level++)
-          {
-          if( mSubmitted[object][size][level]==0 && mRecords[object][size][level]<NO_RECORD )
-            {
-            return true;
-            }
-          }
+      for(int level=0; level<MAX_LEVEL; level++)
+        {
+        if( mSubmitted[object][level]==0 && mRecords[object][level]<NO_RECORD ) return true;
+        }
       }
 
     return false;
@@ -149,43 +136,33 @@ public class RubikScores
 
   synchronized String getRecordList(String strObj, String strLvl, String strTim)
     {
-    ObjectList list;
     StringBuilder builderObj = new StringBuilder();
     StringBuilder builderLvl = new StringBuilder();
     StringBuilder builderTim = new StringBuilder();
     boolean first = true;
-    int[] sizes;
-    int length;
 
     for(int object=0; object<NUM_OBJECTS; object++)
       {
-      list = ObjectList.getObject(object);
-      sizes = list.getSizes();
-      length = sizes.length;
+      String name = ObjectList.getObject(object).name();
 
-      for(int size=0; size<length; size++)
+      for(int level=0; level<MAX_LEVEL; level++)
         {
-        for(int level=0; level<MAX_LEVEL; level++)
+        if( mSubmitted[object][level]==0 && mRecords[object][level]<NO_RECORD )
           {
-          if( mSubmitted[object][size][level]==0 && mRecords[object][size][level]<NO_RECORD )
+          if( !first )
             {
-            if( !first )
-              {
-              builderObj.append(',');
-              builderLvl.append(',');
-              builderTim.append(',');
-              }
-            else
-              {
-              first=false;
-              }
-
-            builderObj.append(list.name());
-            builderObj.append("_");
-            builderObj.append(sizes[size]);
-            builderLvl.append(level);
-            builderTim.append(mRecords[object][size][level]);
+            builderObj.append(',');
+            builderLvl.append(',');
+            builderTim.append(',');
+            }
+          else
+            {
+            first=false;
             }
+
+          builderObj.append(name);
+          builderLvl.append(level);
+          builderTim.append(mRecords[object][level]);
           }
         }
       }
@@ -197,30 +174,16 @@ public class RubikScores
 // Public API
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public synchronized long getRecord(int object, int size, int level)
+  public synchronized long getRecord(int obj, int level)
     {
-    int maxsize = ObjectList.getObject(object).getSizes().length;
-
-    if( object>=0 && object<NUM_OBJECTS && size>=0 && size<maxsize && level>=0 && level<MAX_LEVEL )
-      {
-      return mRecords[object][size][level];
-      }
-
-    return -1;
+    return (obj>=0 && obj<NUM_OBJECTS && level>=0 && level<MAX_LEVEL) ? mRecords[obj][level] : -1;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public synchronized boolean isSubmitted(int object, int size, int level)
+  public synchronized boolean isSubmitted(int obj, int level)
     {
-    int maxsize = ObjectList.getObject(object).getSizes().length;
-
-    if( object>=0 && object<NUM_OBJECTS && size>=0 && size<maxsize && level>=0 && level<MAX_LEVEL )
-      {
-      return mSubmitted[object][size][level]==1;
-      }
-
-    return false;
+    return obj>=0 && obj<NUM_OBJECTS && level>=0 && level<MAX_LEVEL && mSubmitted[obj][level]==1;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -289,16 +252,9 @@ public class RubikScores
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public synchronized boolean isSolved(int object, int size, int level)
+  public synchronized boolean isSolved(int obj, int level)
     {
-    int maxsize = ObjectList.getObject(object).getSizes().length;
-
-    if( object>=0 && object<NUM_OBJECTS && size>=0 && size<maxsize && level>=0 && level<MAX_LEVEL )
-      {
-      return mRecords[object][size][level]<NO_RECORD;
-      }
-
-    return false;
+    return obj>=0 && obj<NUM_OBJECTS && level>=0 && level<MAX_LEVEL && mRecords[obj][level]<NO_RECORD;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -350,9 +306,7 @@ public class RubikScores
   public synchronized void savePreferences(SharedPreferences.Editor editor)
     {
     StringBuilder builder = new StringBuilder();
-    ObjectList list;
-    int[] sizes;
-    int length;
+    String name;
 
     for(int level=0; level<MAX_LEVEL; level++)
       {
@@ -360,21 +314,13 @@ public class RubikScores
 
       for(int object=0; object<NUM_OBJECTS; object++)
         {
-        list = ObjectList.getObject(object);
-        sizes = list.getSizes();
-        length = sizes.length;
-
-        for(int size=0; size<length; size++)
-          {
-          builder.append(list.name());
-          builder.append("_");
-          builder.append(sizes[size]);
-          builder.append("=");
-          builder.append(mRecords[object][size][level]);
-          builder.append(",");
-          builder.append(mSubmitted[object][size][level]);
-          builder.append(" ");
-          }
+        name = ObjectList.getObject(object).name();
+        builder.append(name);
+        builder.append("=");
+        builder.append(mRecords[object][level]);
+        builder.append(",");
+        builder.append(mSubmitted[object][level]);
+        builder.append(" ");
         }
 
       editor.putString("scores_record"+level, builder.toString());
@@ -393,8 +339,7 @@ public class RubikScores
   public synchronized void restorePreferences(SharedPreferences preferences)
     {
     String recordStr, subStr, nameStr, sizeStr, timeStr, submStr, errorStr="";
-    int start, end, equals, underscore, comma;
-    int object, sizeIndex, subm;
+    int start, end, equals, underscore, comma, object, subm;
     long time;
     boolean thereWasError = false;
 
@@ -427,18 +372,17 @@ public class RubikScores
 
           if( object>=0 && object< NUM_OBJECTS )
             {
-            sizeIndex = ObjectList.getSizeIndex(object,Integer.parseInt(sizeStr));
             time = Long.parseLong(timeStr);
             subm = Integer.parseInt(submStr);
 
-            if( sizeIndex>=0 && sizeIndex<MAX_NUM_OBJECTS && subm>=0 && subm<=1 )
+            if( subm>=0 && subm<=1 )
               {
-              mRecords  [object][sizeIndex][level] = time;
-              mSubmitted[object][sizeIndex][level] = subm;
+              mRecords  [object][level] = time;
+              mSubmitted[object][level] = subm;
               }
             else
               {
-              errorStr += ("error1: size="+sizeIndex+" subm="+subm+" obj: "+nameStr+" size: "+sizeStr+"\n");
+              errorStr += ("error1: subm="+subm+" obj: "+nameStr+" size: "+sizeStr+"\n");
               thereWasError= true;
               }
             }
@@ -482,18 +426,13 @@ public class RubikScores
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public synchronized boolean setRecord(int object, int size, int level, long timeTaken)
+  public synchronized boolean setRecord(int object, int level, long timeTaken)
     {
-    int maxsize = ObjectList.getObject(object).getSizes().length;
-
-    if( object>=0 && object<NUM_OBJECTS && size>=0 && size<maxsize && level>=1 && level<=MAX_LEVEL )
+    if( object>=0 && object<NUM_OBJECTS && level>=1 && level<=MAX_LEVEL && mRecords[object][level-1]>timeTaken )
       {
-      if( mRecords[object][size][level-1]> timeTaken )
-        {
-        mRecords  [object][size][level-1] = timeTaken;
-        mSubmitted[object][size][level-1] = 0;
-        return true;
-        }
+      mRecords  [object][level-1] = timeTaken;
+      mSubmitted[object][level-1] = 0;
+      return true;
       }
 
     return false;
diff --git a/src/main/java/org/distorted/patterns/RubikPatternList.java b/src/main/java/org/distorted/patterns/RubikPatternList.java
index bfb96c5f..4c5d85a1 100644
--- a/src/main/java/org/distorted/patterns/RubikPatternList.java
+++ b/src/main/java/org/distorted/patterns/RubikPatternList.java
@@ -25,20 +25,19 @@ import org.distorted.objectlib.main.ObjectList;
 
 public enum RubikPatternList
   {
-  CUBE2 (ObjectList.CUBE, 2, PatternCube2.patterns),
-  CUBE3 (ObjectList.CUBE, 3, PatternCube3.patterns),
-  CUBE4 (ObjectList.CUBE, 4, PatternCube4.patterns),
-  CUBE5 (ObjectList.CUBE, 5, PatternCube5.patterns),
-  PYRA3 (ObjectList.PYRA, 3, PatternPyraminx3.patterns),
-  PYRA4 (ObjectList.PYRA, 4, PatternPyraminx4.patterns),
-  PYRA5 (ObjectList.PYRA, 5, PatternPyraminx5.patterns),
-  MEGA3 (ObjectList.MEGA, 3, PatternMegaminx.patterns),
-  MEGA5 (ObjectList.MEGA, 5, PatternGigaminx.patterns),
+  CUBE2 (ObjectList.CUBE_2, PatternCube2.patterns),
+  CUBE3 (ObjectList.CUBE_3, PatternCube3.patterns),
+  CUBE4 (ObjectList.CUBE_4, PatternCube4.patterns),
+  CUBE5 (ObjectList.CUBE_5, PatternCube5.patterns),
+  PYRA3 (ObjectList.PYRA_3, PatternPyraminx3.patterns),
+  PYRA4 (ObjectList.PYRA_4, PatternPyraminx4.patterns),
+  PYRA5 (ObjectList.PYRA_5, PatternPyraminx5.patterns),
+  MEGA3 (ObjectList.MEGA_3, PatternMegaminx.patterns),
+  MEGA5 (ObjectList.MEGA_5, PatternGigaminx.patterns),
   ;
 
   public static final int NUM_OBJECTS = values().length;
   private final ObjectList mObject;
-  private final int mSize;
   private final String[][] mPatterns;
 
   private static final RubikPatternList[] objects;
@@ -63,10 +62,9 @@ public enum RubikPatternList
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  RubikPatternList(ObjectList object, int size, String[][] patterns)
+  RubikPatternList(ObjectList object, String[][] patterns)
     {
     mObject   = object;
-    mSize     = size;
     mPatterns = patterns;
     }
 
@@ -74,11 +72,11 @@ public enum RubikPatternList
 // PUBLIC API
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public static int getOrdinal(int objectOrdinal, int size)
+  public static int getOrdinal(int object)
     {
     for(int i=0; i<NUM_OBJECTS; i++)
       {
-      if( objects[i].mObject.ordinal() == objectOrdinal && objects[i].mSize == size )
+      if( objects[i].mObject.ordinal() == object )
         {
         return i;
         }
@@ -93,11 +91,4 @@ public enum RubikPatternList
     {
     return objects[ordinal].mObject;
     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public static int getSize(int ordinal)
-    {
-    return objects[ordinal].mSize;
-    }
   }
diff --git a/src/main/java/org/distorted/screens/RubikScreenAbstract.java b/src/main/java/org/distorted/screens/RubikScreenAbstract.java
index c6eb87d5..33243be6 100644
--- a/src/main/java/org/distorted/screens/RubikScreenAbstract.java
+++ b/src/main/java/org/distorted/screens/RubikScreenAbstract.java
@@ -35,12 +35,11 @@ public abstract class RubikScreenAbstract
     {
     RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();
     int obj  = play.getObject();
-    int size = play.getSize();
-    int ret = RubikPatternList.getOrdinal(obj,size);
+    int ret = RubikPatternList.getOrdinal(obj);
 
     if( ret<0 )
       {
-      ret = ObjectList.getSizeIndex(RubikScreenPlay.DEF_OBJECT, RubikScreenPlay.DEF_SIZE);
+      ret = RubikPatternList.getOrdinal(RubikScreenPlay.DEF_OBJECT);
       }
 
     return ret;
@@ -52,13 +51,12 @@ public abstract class RubikScreenAbstract
     {
     RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();
     int obj  = play.getObject();
-    int size = play.getSize();
 
-    int ret = TutorialList.getOrdinal(obj,size);
+    int ret = TutorialList.getOrdinal(obj);
 
     if( ret<0 )
       {
-      ret = ObjectList.getSizeIndex(RubikScreenPlay.DEF_OBJECT, RubikScreenPlay.DEF_SIZE);
+      ret = TutorialList.getOrdinal(RubikScreenPlay.DEF_OBJECT);
       }
 
     return ret;
diff --git a/src/main/java/org/distorted/screens/RubikScreenPattern.java b/src/main/java/org/distorted/screens/RubikScreenPattern.java
index bb7dcdbc..b9a30a6f 100644
--- a/src/main/java/org/distorted/screens/RubikScreenPattern.java
+++ b/src/main/java/org/distorted/screens/RubikScreenPattern.java
@@ -63,16 +63,13 @@ public class RubikScreenPattern extends RubikScreenAbstract
   void leaveScreen(RubikActivity act)
     {
     RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();
-
     ObjectList object = RubikPatternList.getObject(mPatternOrdinal);
-    int size = RubikPatternList.getSize(mPatternOrdinal);
 
-    if( !play.setObjectAndSize(act,object,size) )
+    if( !play.setObject(act,object) )
       {
       int objectPlay= play.getObject();
-      int sizePlay  = play.getSize();
 
-      act.changeObject(ObjectList.getObject(objectPlay),sizePlay, false);
+      act.changeObject(ObjectList.getObject(objectPlay),false);
       }
     }
 
diff --git a/src/main/java/org/distorted/screens/RubikScreenPlay.java b/src/main/java/org/distorted/screens/RubikScreenPlay.java
index 376903c3..85ef269e 100644
--- a/src/main/java/org/distorted/screens/RubikScreenPlay.java
+++ b/src/main/java/org/distorted/screens/RubikScreenPlay.java
@@ -53,8 +53,7 @@ import org.distorted.network.RubikScores;
 public class RubikScreenPlay extends RubikScreenBase
   {
   public static final int LEVELS_SHOWN = 10;
-  public static final int DEF_OBJECT= ObjectList.CUBE.ordinal();
-  public static final int DEF_SIZE  =  3;
+  public static final int DEF_OBJECT= ObjectList.CUBE_3.ordinal();
 
   private static final int[] BUTTON_LABELS = { R.string.scores,
                                                R.string.patterns,
@@ -71,7 +70,6 @@ public class RubikScreenPlay extends RubikScreenBase
   private Button mPlayButton;
   private PopupWindow mObjectPopup, mMenuPopup, mPlayPopup;
   private int mObject = DEF_OBJECT;
-  private int mSize   = DEF_SIZE;
   private int mObjectSize, mMenuLayoutWidth, mMenuLayoutHeight, mPlayLayoutWidth;
   private int mLevelValue;
   private float mButtonSize, mMenuItemSize, mMenuTextSize;
@@ -79,8 +77,6 @@ public class RubikScreenPlay extends RubikScreenBase
   private LinearLayout mPlayLayout;
   private int mUpperBarHeight;
 
-  private boolean mIsFullScreen;
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   void leaveScreen(RubikActivity act)
@@ -166,8 +162,7 @@ public class RubikScreenPlay extends RubikScreenBase
           {
           View popupView = mPlayPopup.getContentView();
           popupView.setSystemUiVisibility(RubikActivity.FLAGS);
-          final int sizeIndex = ObjectList.getSizeIndex(mObject,mSize);
-          final int dbLevel = ObjectList.getDBLevel(mObject, sizeIndex);
+          final int dbLevel = ObjectList.getDBLevel(mObject);
           final int levelsShown = Math.min(dbLevel,LEVELS_SHOWN);
           final int popupHeight = (int)(levelsShown*(mMenuItemSize+margin)+3*margin+mMenuItemSize*(LAST_BUTTON-1.0f));
           final int realHeight = Math.min(popupHeight,maxHeight);
@@ -205,7 +200,7 @@ public class RubikScreenPlay extends RubikScreenBase
 
   private void setupObjectWindow(final RubikActivity act, final float width, final float height)
     {
-    int icon = RubikActivity.getDrawable(R.drawable.ui_small_cube2,R.drawable.ui_medium_cube2, R.drawable.ui_big_cube2, R.drawable.ui_huge_cube2);
+    int icon = RubikActivity.getDrawable(R.drawable.small_cube2,R.drawable.medium_cube2, R.drawable.big_cube2, R.drawable.huge_cube2);
 
     BitmapDrawable bd = (BitmapDrawable) act.getResources().getDrawable(icon);
     int cubeWidth = bd.getIntrinsicWidth();
@@ -250,47 +245,39 @@ public class RubikScreenPlay extends RubikScreenBase
     for(int object=0; object< ObjectList.NUM_OBJECTS; object++)
       {
       final ObjectList list = ObjectList.getObject(object);
-      final int[] sizes = list.getSizes();
       int iconSize = RubikActivity.getDrawableSize();
-      int[] icons = list.getIconIDs(iconSize);
-      int len = sizes.length;
+      int icons = list.getIconID(iconSize);
       final int obj = object;
       int row = indices[object];
 
-      for(int i=0; i<len; i++)
+      ImageButton button = new ImageButton(act);
+      button.setBackgroundResource(icons);
+      button.setOnClickListener( new View.OnClickListener()
         {
-        final int index = i;
-
-        ImageButton button = new ImageButton(act);
-        button.setBackgroundResource(icons[i]);
-        button.setOnClickListener( new View.OnClickListener()
+        @Override
+        public void onClick(View v)
           {
-          @Override
-          public void onClick(View v)
+          if( act.getPreRender().isUINotBlocked() && ScreenList.getCurrentScreen()== ScreenList.PLAY )
             {
-            if( act.getPreRender().isUINotBlocked() && ScreenList.getCurrentScreen()== ScreenList.PLAY )
-              {
-              mObject = obj;
-              mSize   = sizes[index];
-              act.changeObject(list,sizes[index], true);
-              adjustLevels(act);
-              mController.clearMoves(act);
-              }
-
-            mObjectPopup.dismiss();
+            mObject = obj;
+            act.changeObject(list, true);
+            adjustLevels(act);
+            mController.clearMoves(act);
             }
-          });
 
-        GridLayout.LayoutParams params = new GridLayout.LayoutParams(rowSpecs[row],colSpecs[nextInRow[row]]);
-        params.bottomMargin = margin;
-        params.topMargin    = margin;
-        params.leftMargin   = margin;
-        params.rightMargin  = margin;
+          mObjectPopup.dismiss();
+          }
+        });
 
-        nextInRow[row]++;
+      GridLayout.LayoutParams params = new GridLayout.LayoutParams(rowSpecs[row],colSpecs[nextInRow[row]]);
+      params.bottomMargin = margin;
+      params.topMargin    = margin;
+      params.leftMargin   = margin;
+      params.rightMargin  = margin;
 
-        objectGrid.addView(button, params);
-        }
+      nextInRow[row]++;
+
+      objectGrid.addView(button, params);
       }
     }
 
@@ -360,10 +347,8 @@ public class RubikScreenPlay extends RubikScreenBase
       {
       case 0: RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();
               int object = play.getObject();
-              int size   = play.getSize();
-              int sizeIndex = ObjectList.getSizeIndex(object,size);
               Bundle sBundle = new Bundle();
-              sBundle.putInt("tab", ObjectList.pack(object,sizeIndex) );
+              sBundle.putInt("tab", object );
               sBundle.putBoolean("submitting", false);
               RubikDialogScores scores = new RubikDialogScores();
               scores.setArguments(sBundle);
@@ -420,7 +405,6 @@ public class RubikScreenPlay extends RubikScreenBase
   public void savePreferences(SharedPreferences.Editor editor)
     {
     editor.putInt("statePlay_object", mObject);
-    editor.putInt("statePlay_size"  , mSize);
 
     if( mObjectPopup!=null )
       {
@@ -446,49 +430,27 @@ public class RubikScreenPlay extends RubikScreenBase
   public void restorePreferences(SharedPreferences preferences)
     {
     mObject= preferences.getInt("statePlay_object", DEF_OBJECT);
-    mSize  = preferences.getInt("statePlay_size"  , DEF_SIZE  );
-
-    int sizeIndex = ObjectList.getSizeIndex(mObject,mSize);
-    int dbLevel = ObjectList.getDBLevel(mObject, sizeIndex);
+    int dbLevel = ObjectList.getDBLevel(mObject);
 
     // This means the app has been upgraded to a new version which swapped the
     // Object for a new one with larger sizeIndex and now getMaxLevel() returns
     // 0. Reset the object to default, otherwise we'll get a crash later on.
 
-    if( dbLevel==0 )
-      {
-      mObject = DEF_OBJECT;
-      mSize   = DEF_SIZE;
-      }
+    if( dbLevel==0 ) mObject = DEF_OBJECT;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public boolean setObjectAndSize(RubikActivity act, ObjectList obj, int size)
+  public boolean setObject(RubikActivity act, ObjectList obj)
     {
-    if( mObject!=obj.ordinal() || mSize != size )
+    if( mObject!=obj.ordinal() )
       {
-      boolean success = false;
-
-      for( int s: obj.getSizes() )
-        if( s==size )
-          {
-          success = true;
-          break;
-          }
-
-      if( success )
-        {
-        mObject = obj.ordinal();
-        mSize   = size;
-
-        if( mPlayLayout!=null ) adjustLevels(act);
-        }
-
-      return success;
+      mObject = obj.ordinal();
+      if( mPlayLayout!=null ) adjustLevels(act);
+      return true;
       }
 
-    return true;
+    return false;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -497,19 +459,20 @@ public class RubikScreenPlay extends RubikScreenBase
   private void displayPopup(RubikActivity act, View view, PopupWindow window, int w, int h, int xoff, int yoff)
     {
     View topLayout = act.findViewById(R.id.relativeLayout);
+    boolean isFullScreen;
 
     if( topLayout!=null )
       {
       topLayout.getLocationOnScreen(mLocation);
-      mIsFullScreen = (mLocation[1]==0);
+      isFullScreen = (mLocation[1]==0);
       }
     else
       {
-      mIsFullScreen = true;
+      isFullScreen = true;
       }
 
     // if on Android 11 or we are fullscreen
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R || mIsFullScreen )
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R || isFullScreen )
       {
       window.showAsDropDown(view, xoff, yoff, Gravity.CENTER);
       window.update(view, w, h);
@@ -531,9 +494,8 @@ public class RubikScreenPlay extends RubikScreenBase
 
   private void adjustLevels(final RubikActivity act)
     {
-    int sizeIndex = ObjectList.getSizeIndex(mObject,mSize);
-    int dbLevel = ObjectList.getDBLevel(mObject, sizeIndex);
-    int numScrambles = ObjectList.getNumScramble(mObject, sizeIndex);
+    int dbLevel = ObjectList.getDBLevel(mObject);
+    int numScrambles = ObjectList.getNumScramble(mObject);
     int numLevel = Math.min(dbLevel, LEVELS_SHOWN);
     String[] levels = new String[numLevel];
 
@@ -580,7 +542,7 @@ public class RubikScreenPlay extends RubikScreenBase
       button.setText(levels[i]);
       button.setTextSize(TypedValue.COMPLEX_UNIT_PX, mMenuTextSize);
 
-      int icon = scores.isSolved(mObject, sizeIndex, level-1) ? R.drawable.ui_solved : R.drawable.ui_notsolved;
+      int icon = scores.isSolved(mObject, level-1) ? R.drawable.ui_solved : R.drawable.ui_notsolved;
       button.setCompoundDrawablesWithIntrinsicBounds(icon,0,0,0);
 
       button.setOnClickListener( new View.OnClickListener()
@@ -616,11 +578,4 @@ public class RubikScreenPlay extends RubikScreenBase
     {
     return mObject;
     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public int getSize()
-    {
-    return mSize;
-    }
   }
diff --git a/src/main/java/org/distorted/screens/RubikScreenSolver.java b/src/main/java/org/distorted/screens/RubikScreenSolver.java
index 6a0871cc..dc105a56 100644
--- a/src/main/java/org/distorted/screens/RubikScreenSolver.java
+++ b/src/main/java/org/distorted/screens/RubikScreenSolver.java
@@ -80,11 +80,10 @@ public class RubikScreenSolver extends RubikScreenAbstract
     mSolving = false;
 
     ObjectList currentObject= ImplementedSolversList.getObject(0);
-    int currentObjectSize   = ImplementedSolversList.getObjectSize(0);
 
-    act.setupObject(currentObject, currentObjectSize, null);
+    act.setupObject(currentObject,null);
     RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();
-    play.setObjectAndSize(act, currentObject, currentObjectSize);
+    play.setObject(act, currentObject);
 
     generateFaceColors();
 
diff --git a/src/main/java/org/distorted/screens/RubikScreenSolving.java b/src/main/java/org/distorted/screens/RubikScreenSolving.java
index b1b8eba6..a03d0518 100644
--- a/src/main/java/org/distorted/screens/RubikScreenSolving.java
+++ b/src/main/java/org/distorted/screens/RubikScreenSolving.java
@@ -188,11 +188,8 @@ public class RubikScreenSolving extends RubikScreenBase
 
       RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();
       int object  = play.getObject();
-      int size    = play.getSize();
       int level   = play.getLevel();
-      int realSize= ObjectList.getSizeIndex(object,size);
-
-      boolean isNew = mScores.setRecord(object, realSize, level, mElapsed);
+      boolean isNew = mScores.setRecord(object, level, mElapsed);
 
       return isNew ? mElapsed : -mElapsed;
       }
diff --git a/src/main/java/org/distorted/solvers/ImplementedSolversList.java b/src/main/java/org/distorted/solvers/ImplementedSolversList.java
index 9a404997..272cb20a 100644
--- a/src/main/java/org/distorted/solvers/ImplementedSolversList.java
+++ b/src/main/java/org/distorted/solvers/ImplementedSolversList.java
@@ -25,13 +25,12 @@ import org.distorted.objectlib.main.ObjectList;
 
 public enum ImplementedSolversList
 {
-  CUBE3 ( ObjectList.CUBE, 3),
+  CUBE3 ( ObjectList.CUBE_3),
   ;
 
   public static final int NUM_OBJECTS = values().length;
 
   private final ObjectList mObject;
-  private final int mObjectSize;
 
   private static final ImplementedSolversList[] objects;
 
@@ -55,16 +54,8 @@ public enum ImplementedSolversList
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public static int getObjectSize(int ordinal)
+  ImplementedSolversList(ObjectList object)
     {
-    return objects[ordinal].mObjectSize;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  ImplementedSolversList(ObjectList object, int size)
-    {
-    mObject     = object;
-    mObjectSize =  size;
+    mObject= object;
     }
 }
diff --git a/src/main/java/org/distorted/solvers/SolverMain.java b/src/main/java/org/distorted/solvers/SolverMain.java
index ea494521..419b5c9d 100644
--- a/src/main/java/org/distorted/solvers/SolverMain.java
+++ b/src/main/java/org/distorted/solvers/SolverMain.java
@@ -49,9 +49,9 @@ public class SolverMain implements Runnable
 // If a certain cubit is locked, return the color (index into it's FACE_COLORS array) it
 // must have. Otherwise return -1.
 
-  public static int cubitIsLocked(ObjectList object, int size, int cubit)
+  public static int cubitIsLocked(ObjectList object, int cubit)
     {
-    if( object == ObjectList.CUBE && size == 3)
+    if( object == ObjectList.CUBE_3 )
       {
       if( cubit==21 ) return 0; // center of the right  face
       if( cubit== 4 ) return 1; // center of the left   face
@@ -248,7 +248,7 @@ public class SolverMain implements Runnable
     {
     RubikScreenSolver solver = (RubikScreenSolver) ScreenList.SVER.getScreenClass();
 
-    if( mObject.getObjectList()==ObjectList.CUBE && mObject.getNumLayers()==3 )
+    if( mObject.getObjectList()==ObjectList.CUBE_3 )
       {
       solveCube3(solver);
       }
diff --git a/src/main/java/org/distorted/tutorials/TutorialActivity.java b/src/main/java/org/distorted/tutorials/TutorialActivity.java
index 78cf6f75..67e61d2c 100644
--- a/src/main/java/org/distorted/tutorials/TutorialActivity.java
+++ b/src/main/java/org/distorted/tutorials/TutorialActivity.java
@@ -63,7 +63,7 @@ public class TutorialActivity extends TwistyActivity
     private int mCurrentApiVersion;
     private TutorialState mState;
     private String mURL;
-    private int mObjectOrdinal, mObjectSize;
+    private int mObjectOrdinal;
     private TutorialWebView mWebView;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -82,7 +82,6 @@ public class TutorialActivity extends TwistyActivity
         {
         mURL           = b.getString("url");
         mObjectOrdinal = b.getInt("obj");
-        mObjectSize    = b.getInt("siz");
         }
 
       unlock();
@@ -211,13 +210,7 @@ public class TutorialActivity extends TwistyActivity
       if( mObjectOrdinal>=0 && mObjectOrdinal< ObjectList.NUM_OBJECTS )
         {
         ObjectList obj = ObjectList.getObject(mObjectOrdinal);
-        int[] sizes = obj.getSizes();
-        int sizeIndex = ObjectList.getSizeIndex(mObjectOrdinal,mObjectSize);
-
-        if( sizeIndex>=0 && sizeIndex<sizes.length )
-          {
-          view.getPreRender().changeObject(obj,mObjectSize);
-          }
+        view.getPreRender().changeObject(obj);
         }
       }
     
diff --git a/src/main/java/org/distorted/tutorials/TutorialList.java b/src/main/java/org/distorted/tutorials/TutorialList.java
index 9b1e60d2..b08e82a1 100644
--- a/src/main/java/org/distorted/tutorials/TutorialList.java
+++ b/src/main/java/org/distorted/tutorials/TutorialList.java
@@ -26,7 +26,7 @@ import org.distorted.main.RubikActivity;
 
 public enum TutorialList
 {
-  CUBE2 ( ObjectList.CUBE, 2,
+  CUBE2 ( ObjectList.CUBE_2,
           new String[][] {
                           {"gb","rJlh5p2wAKA","How to Solve a 2x2 Rubik's Cube","Z3"},
                           {"es","f85wqJTIDlw","Resolver cubo de Rubik 2X2","Cuby"},
@@ -39,7 +39,7 @@ public enum TutorialList
                          }
         ),
 
-  CUBE3 ( ObjectList.CUBE, 3,
+  CUBE3 ( ObjectList.CUBE_3,
           new String[][] {
                           {"gb","-8ohoCKN0Zw","How to Solve a Rubik's Cube","Z3"},
                           {"es","GyY0OxDk5lI","Resolver cubo de Rubik 3x3","Cuby"},
@@ -54,7 +54,7 @@ public enum TutorialList
                          }
         ),
 
-  CUBE4 ( ObjectList.CUBE, 4,
+  CUBE4 ( ObjectList.CUBE_4,
           new String[][] {
                           {"gb","RR77Md71Ymc","How to Solve the 4x4 Rubik's Cube","Z3"},
                           {"es","d_4xk1r9hxU","Resolver cubo de Rubik 4x4","Cuby"},
@@ -71,7 +71,7 @@ public enum TutorialList
                          }
         ),
 
-  CUBE5 ( ObjectList.CUBE, 5,
+  CUBE5 ( ObjectList.CUBE_5,
           new String[][] {
                           {"gb","zMkNkXHzQts","How to Solve the 5x5 Rubik's Cube","Z3"},
                           {"es","6uaq-xfFs98","Resolver cubo de Rubik 5x5","Cuby"},
@@ -83,7 +83,7 @@ public enum TutorialList
                          }
         ),
 
-  JING  ( ObjectList.JING, 2,
+  JING  ( ObjectList.JING_2,
           new String[][] {
                           {"gb","0T8Iw6aI2gA","Jing's Pyraminx Tutorial","SuperAntoniovivaldi"},
                           {"es","Na27_GUIzqY","Resolver Jing Pyraminx","Cuby"},
@@ -94,7 +94,7 @@ public enum TutorialList
                          }
         ),
 
-  PYRA3 ( ObjectList.PYRA, 3,
+  PYRA3 ( ObjectList.PYRA_3,
           new String[][] {
                           {"gb","xIQtn2qazvg","Pyraminx Layer By Layer","Z3"},
                           {"es","4cJJe9RAzAU","Resolver Pyraminx","Cuby"},
@@ -107,7 +107,7 @@ public enum TutorialList
                          }
         ),
 
-  PYRA4 ( ObjectList.PYRA, 4,
+  PYRA4 ( ObjectList.PYRA_4,
           new String[][] {
                           {"gb","tGQDqDcSa6U","How to Solve the Master Pyraminx","Z3"},
                           {"es","74PIPm9-uPg","Resolver Master Pyraminx 4x4","Cuby"},
@@ -119,7 +119,7 @@ public enum TutorialList
                          }
         ),
 
-  PYRA5 ( ObjectList.PYRA, 5,
+  PYRA5 ( ObjectList.PYRA_5,
           new String[][] {
                           {"gb","2nsPEECDdN0","Professor Pyraminx Solve","RedKB"},
                           {"es","cSDj8OQK3TU","Tutorial del Professor Pyraminx","QBAndo"},
@@ -129,7 +129,7 @@ public enum TutorialList
                          }
         ),
 
-  KILO3( ObjectList.KILO, 3,
+  KILO3( ObjectList.KILO_3,
           new String[][] {
                           {"gb","grgGgUSxiQg","How to Solve the Kilominx","Z3"},
                           {"es","g6WMYjkCLok","Resolver Kilominx","Cuby"},
@@ -141,7 +141,7 @@ public enum TutorialList
                          }
        ),
 
-  KILO5( ObjectList.KILO, 5,
+  KILO5( ObjectList.KILO_5,
           new String[][] {
                           {"gb","VAnzC2SYVc4","How To Solve A Master Kilominx","Grizz Media"},
                           {"es","ozINTg-61Fs","Tutorial Master Kilominx","RubikArt"},
@@ -156,7 +156,7 @@ public enum TutorialList
                          }
        ),
 
-  MEGA3( ObjectList.MEGA, 3,
+  MEGA3( ObjectList.MEGA_3,
           new String[][] {
                           {"gb","j4x61L5Onzk","How to Solve the Megaminx","Z3"},
                           {"es","xuKbT6Il0Ko","Resolver Megaminx","Cuby"},
@@ -168,7 +168,7 @@ public enum TutorialList
                          }
        ),
 
-  MEGA5( ObjectList.MEGA, 5,
+  MEGA5( ObjectList.MEGA_5,
           new String[][] {
                           {"gb","MNBMm8BnHtQ","Solve the Gigaminx Part 1","BeardedCubing"},
                           {"gb","QrrP4GwqVMw","Solve the Gigaminx Part 2","BeardedCubing"},
@@ -186,7 +186,7 @@ public enum TutorialList
                          }
        ),
 
-  ULTI ( ObjectList.ULTI, 2,
+  ULTI ( ObjectList.ULTI_2,
           new String[][] {
                           {"gb","n1ikPKZxGEo","Ultimate Skewb Tutorial","BeardedCubing"},
                           {"es","wNL1WJ_sCfs","Resolver Skewb ULTIMATE","Cuby"},
@@ -198,7 +198,7 @@ public enum TutorialList
                          }
         ),
 
-  DIAM2 ( ObjectList.DIAM, 2,
+  DIAM2 ( ObjectList.DIAM_2,
           new String[][] {
                           {"gb","R2wrbJJ3izM","How to Solve a Skewb Diamond","Dr. Penguin^3"},
                           {"es","2RCusYQdYYE","Como resolver Skewb Diamond","Tutoriales Rubik"},
@@ -210,7 +210,7 @@ public enum TutorialList
                          }
        ),
 
-  DIAM3 ( ObjectList.DIAM, 3,
+  DIAM3 ( ObjectList.DIAM_3,
           new String[][] {
                           {"gb","n_mBSUDLUZw","Face Turning Octahedron Tutorial","SuperAntoniovivaldi"},
                           {"es","ogf0t6fGxZI","FTO - Tutorial en español","Gadi Rubik"},
@@ -220,7 +220,7 @@ public enum TutorialList
                          }
        ),
 
-  DIAM4 ( ObjectList.DIAM, 4,
+  DIAM4 ( ObjectList.DIAM_4,
           new String[][] {
                           {"gb","3GJkySk5zeQ","Master Face Turning Octahedron","SuperAntoniovivaldi"},
                           {"gb","zW_1htxy52k","Master FTO Tutorial","Michele Regano"},
@@ -229,7 +229,7 @@ public enum TutorialList
                          }
        ),
 
-  DINO3 ( ObjectList.DINO, 3,
+  DINO3 ( ObjectList.DINO_3,
           new String[][] {
                           {"gb","puTJZqFBQwo","Dino Skewb Cube Tutorial","Bearded Cubing"},
                           {"es","6o1Yo5iCxvI","Resolver Cubo Dino","Cuby"},
@@ -241,7 +241,7 @@ public enum TutorialList
                          }
         ),
 
-  REDI3 ( ObjectList.REDI, 3,
+  REDI3 ( ObjectList.REDI_3,
           new String[][] {
                           {"gb","Qn7TJED6O-4","How to Solve the MoYu Redi Cube","Z3"},
                           {"es","g0M38Aotgac","Resolver Redi Cube","Cuby"},
@@ -253,7 +253,7 @@ public enum TutorialList
                          }
         ),
 
-  HELI3 ( ObjectList.HELI, 3,
+  HELI3 ( ObjectList.HELI_3,
           new String[][] {
                           {"gb","-suwJpd_PO8","Helicopter Cube Tutorial","Bearded Cubing"},
                           {"es","DWG9n_YyGPA","Resolver Helicopter Cube","Cuby"},
@@ -265,7 +265,7 @@ public enum TutorialList
                          }
         ),
 
-  SKEW2 ( ObjectList.SKEW, 2,
+  SKEW2 ( ObjectList.SKEW_2,
           new String[][] {
                           {"gb","I6132yshkeU","How to Solve the Skewb","Z3"},
                           {"es","wxQX3HhPgds","Resolver Skewb (Principiantes)","Cuby"},
@@ -278,7 +278,7 @@ public enum TutorialList
                          }
         ),
 
-  SKEW3 ( ObjectList.SKEW, 3,
+  SKEW3 ( ObjectList.SKEW_3,
           new String[][] {
                           {"gb","Jiuf7zQyPYI","Master Skewb Cube Tutorial","Bearded Cubing"},
                           {"es","8TP6p63KQCA","Master Skewb en Español","jorlozCubes"},
@@ -293,7 +293,7 @@ public enum TutorialList
                          }
         ),
 
-  IVY2 ( ObjectList.IVY, 2,
+  IVY2 ( ObjectList.IVY_2,
           new String[][] {
                           {"gb","QMzeJobSu1M","How to Solve the Ivy Cube","Z3"},
                           {"es","2-Gf2cmEJDs","Resolver Ivy Cube","Cuby"},
@@ -305,7 +305,7 @@ public enum TutorialList
                          }
         ),
 
-  REX3 ( ObjectList.REX, 3,
+  REX3 ( ObjectList.REX_3,
           new String[][] {
                           {"gb","noAQfWqlMbk","Rex Cube Tutorial","CrazyBadCuber"},
                           {"es","Q90x9rjLJzw","Resolver Cubo Rex","Cuby"},
@@ -317,7 +317,7 @@ public enum TutorialList
                          }
         ),
 
-  BAN1( ObjectList.BAN1, 3,
+  BAN1( ObjectList.BAN1_3,
           new String[][] {
                           {"gb","F_iJk_IvpVo","Bandaged Cube","CanChrisSolve"},
                           {"es","_lTgw5aEFOg","Tutorial 3x3 Fuse Cube","QBAndo"},
@@ -328,7 +328,7 @@ public enum TutorialList
                          }
        ),
 
-  BAN2( ObjectList.BAN2, 3,
+  BAN2( ObjectList.BAN2_3,
           new String[][] {
                           {"ru","lS_EK0PMWI8","Как собрать 2-bar Cube","Алексей Ярыгин"},
                           {"pl","tX8ubTLh6p8","Bandaged 3x3 (Two bar)","MrUK"},
@@ -336,7 +336,7 @@ public enum TutorialList
                          }
        ),
 
-  BAN3( ObjectList.BAN3, 3,
+  BAN3( ObjectList.BAN3_3,
           new String[][] {
                           {"gb","7UiCVGygUT4","Bandage Cube C Tutorial","PolyakB"},
                           {"ru","gXenRA92Wdc","Как собрать Bandaged 3x3 Type C","YG Cuber"},
@@ -345,7 +345,7 @@ public enum TutorialList
                          }
        ),
 
-  BAN4( ObjectList.BAN4, 3,
+  BAN4( ObjectList.BAN4_3,
           new String[][] {
                           {"gb","AnpdIKICBpM","Trying to Solve a Bandaged Cube","RedKB"},
                           {"es","cUyo5fycrvI","Tutorial Bandaged Cube en español","Rafa Garcia Benacazon"},
@@ -357,7 +357,7 @@ public enum TutorialList
                          }
        ),
 
-  SQUA1 ( ObjectList.SQU1, 3,
+  SQUA1 ( ObjectList.SQU1_3,
           new String[][] {
                           {"gb","0tX-f6RLgac","How to Solve the Square-1","Z3"},
                           {"es","mGtHDWj_i1o","Resolver SQUARE-1","Cuby"},
@@ -372,7 +372,7 @@ public enum TutorialList
                          }
        ),
 
-  SQUA2 ( ObjectList.SQU2, 3,
+  SQUA2 ( ObjectList.SQU2_3,
           new String[][] {
                           {"gb","PPXojiFthEs","Square-2 Tutorial","SuperAntoniovivaldi"},
                           {"es","IiMwc51xKBQ","Cómo resolver Square-2","skieur cubb"},
@@ -383,7 +383,7 @@ public enum TutorialList
                          }
        ),
 
-  MIRR2 ( ObjectList.MIRR, 2,
+  MIRR2 ( ObjectList.MIRR_2,
           new String[][] {
                           {"gb","rSH-ZEqTmxs","Solve 2x2 Mirror Blocks","King of Cubing"},
                           {"es","Ipz-Ajpd4Fg","Como resolver el mirror 2x2","RUBI CUBI"},
@@ -394,7 +394,7 @@ public enum TutorialList
                          }
        ),
 
-  MIRR3 ( ObjectList.MIRR, 3,
+  MIRR3 ( ObjectList.MIRR_3,
           new String[][] {
                           {"gb","YkzXIWnqbSw","How to Solve the Mirror Cube","Z3"},
                           {"es","ZTkunMo51l0","Resolver cubo de Rubik MIRROR","Cuby"},
@@ -409,7 +409,6 @@ public enum TutorialList
 
   public static final int NUM_OBJECTS = values().length;
   private final ObjectList mObject;
-  private final int mSize;
   private final String[][] mTutorials;
   private final int mNumTutorials;
 
@@ -428,10 +427,9 @@ public enum TutorialList
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  TutorialList(ObjectList object, int size, String[][] tutorials)
+  TutorialList(ObjectList object, String[][] tutorials)
     {
     mObject       = object;
-    mSize         = size;
     mTutorials    = tutorials;
     mNumTutorials = mTutorials.length;
     }
@@ -445,16 +443,16 @@ public enum TutorialList
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public static int getOrdinal(int objectOrdinal, int size)
+  public static int getOrdinal(int object)
     {
-    if( objectOrdinal==ObjectList.DIN4.ordinal() )
+    if( object==ObjectList.DIN4_3.ordinal() )
       {
-      objectOrdinal= ObjectList.DINO.ordinal();
+      object= ObjectList.DINO_3.ordinal();
       }
 
     for(int i=0; i<NUM_OBJECTS; i++)
       {
-      if( objects[i].mObject.ordinal() == objectOrdinal && objects[i].mSize == size )
+      if( objects[i].mObject.ordinal() == object )
         {
         return i;
         }
@@ -470,13 +468,6 @@ public enum TutorialList
     return mObject;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public int getSize()
-    {
-    return mSize;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public int getNumTutorials()
@@ -488,9 +479,8 @@ public enum TutorialList
 
   public int getIconID()
     {
-    int sizeIndex = ObjectList.getSizeIndex(mObject.ordinal(),mSize);
     int iconSize  = RubikActivity.getDrawableSize();
-    return mObject.getIconIDs(iconSize)[sizeIndex];
+    return mObject.getIconID(iconSize);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/tutorials/TutorialPreRender.java b/src/main/java/org/distorted/tutorials/TutorialPreRender.java
index 7c6ea718..97d540e5 100644
--- a/src/main/java/org/distorted/tutorials/TutorialPreRender.java
+++ b/src/main/java/org/distorted/tutorials/TutorialPreRender.java
@@ -43,7 +43,6 @@ public class TutorialPreRender implements EffectController, TwistyPreRender
   private boolean mUIBlocked, mTouchBlocked;
   private boolean mIsSolved;
   private ObjectList mNextObject;
-  private int mNextSize;
   private long mRotationFinishedID;
   private int mScreenWidth;
   private TwistyObject mOldObject, mNewObject;
@@ -85,7 +84,7 @@ public class TutorialPreRender implements EffectController, TwistyPreRender
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private void createObjectNow(ObjectList object, int size)
+  private void createObjectNow(ObjectList object)
     {
     if( mOldObject!=null ) mOldObject.releaseResources();
     mOldObject = mNewObject;
@@ -93,7 +92,7 @@ public class TutorialPreRender implements EffectController, TwistyPreRender
     Context con = mView.getContext();
     Resources res = con.getResources();
 
-    mNewObject = object.create(size, mView.getQuat(), null, res, mScreenWidth);
+    mNewObject = object.create(mView.getQuat(), null, res, mScreenWidth);
 
     if( mNewObject!=null )
       {
@@ -189,10 +188,10 @@ public class TutorialPreRender implements EffectController, TwistyPreRender
     {
     mChangeObject = false;
 
-    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getNumLayers()!=mNextSize)
+    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject)
       {
       blockEverything(BlockController.TUTORIAL_PLACE_1);
-      createObjectNow(mNextObject, mNextSize);
+      createObjectNow(mNextObject);
       doEffectNow( BaseEffect.Type.SIZECHANGE );
       }
     }
@@ -203,10 +202,10 @@ public class TutorialPreRender implements EffectController, TwistyPreRender
     {
     mSetupObject = false;
 
-    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject || mNewObject.getNumLayers()!=mNextSize)
+    if ( mNewObject==null || mNewObject.getObjectList()!=mNextObject)
       {
       blockEverything(BlockController.TUTORIAL_PLACE_2);
-      createObjectNow(mNextObject, mNextSize);
+      createObjectNow(mNextObject);
       doEffectNow( BaseEffect.Type.SIZECHANGE );
       }
     else
@@ -292,14 +291,10 @@ public class TutorialPreRender implements EffectController, TwistyPreRender
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  void changeObject(ObjectList object, int size)
+  void changeObject(ObjectList object)
     {
-    if( size>0 )
-      {
-      mChangeObject = true;
-      mNextObject = object;
-      mNextSize   = size;
-      }
+    mChangeObject = true;
+    mNextObject = object;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -437,13 +432,6 @@ public class TutorialPreRender implements EffectController, TwistyPreRender
       }
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public void resetAllTextureMaps()
-    {
-    mResetAllTextureMaps = true;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public TwistyObject getObject()
diff --git a/src/main/java/org/distorted/tutorials/TutorialState.java b/src/main/java/org/distorted/tutorials/TutorialState.java
index 1ed6ecdb..d91c17cd 100644
--- a/src/main/java/org/distorted/tutorials/TutorialState.java
+++ b/src/main/java/org/distorted/tutorials/TutorialState.java
@@ -72,11 +72,7 @@ public class TutorialState
       public void onClick(View v)
         {
         RubikScreenPlay play = (RubikScreenPlay) ScreenList.PLAY.getScreenClass();
-        int size = play.getSize();
-        int object= play.getObject();
-        int sizeIndex = ObjectList.getSizeIndex(object,size);
-        int numScrambles = ObjectList.getNumScramble(object, sizeIndex);
-
+        int numScrambles = ObjectList.getNumScramble(play.getObject());
         act.getPreRender().scrambleObject(numScrambles);
         }
       });