/src/main/java/org/distorted/objects/RubikObjectCategories.java - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision 48e61813

Added by Leszek Koltunski 4 months ago

ID 48e61813c5eb5ffde4bddd33bf14042254f41f3f
Parent acee3e3e
Child 881697b3

progress

     import org.distorted.main.R;
     import java.util.Arrays;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     public class RubikObjectCategories
     public abstract class RubikObjectCategories
+    {
       public static final int[] DIFF_IDS =
+        {
-...
         R.drawable.difficulty5,
         };
       private final int mNumCategories;
       private int[][] mObjectIndices;
       private int[] mIconIDs;
       private String[] mTitles;
       protected final int mNumCategories;
       protected int[] mIconIDs;
       protected String[] mTitles;
       protected int[][] mObjectIndices;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public RubikObjectCategories(int sortMode)
       public RubikObjectCategories()
+        {
         switch(sortMode)
+          {
           case SORT_CATEGORY  : buildSortCategory(); break;
           case SORT_DIFFICULTY: buildSortDifficulty(); break;
           case SORT_AUTHOR    : buildSortAuthor(); break;
           case SORT_YEAR      : buildSortYear(); break;
+          }
         buildIndices();
         mNumCategories = mObjectIndices.length;
         switch(sortMode)
+          {
           case SORT_CATEGORY  : buildIconsCategory(); break;
           case SORT_DIFFICULTY: buildIconsDifficulty(); break;
           case SORT_AUTHOR    : buildTitleAuthor(); break;
           case SORT_YEAR      : buildTitleYear(); break;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildSortStr(String[] data)
+        {
         int numObjects = data.length;
         String[] sorted = new String[numObjects];
         System.arraycopy(data, 0, sorted, 0, numObjects);
         Arrays.sort(sorted);
         String[] categories = new String[numObjects];
         int numCategories = 0;
         for(int o=0; o<numObjects; o++)
           if( o==0 || !sorted[o-1].equals(sorted[o]) )
+            {
             categories[numCategories] = sorted[o];
             numCategories++;
+            }
         int lastChange = -1;
         int curr = 0;
         int[] numInCategory = new int[numCategories];
         for(int o=0; o<numObjects; o++)
           if( o==numObjects-1 || !sorted[o].equals(sorted[o+1]) )
+            {
             numInCategory[curr] = o-lastChange;
             curr++;
             lastChange = o;
+            }
         mObjectIndices = new int[numCategories][];
         for(int c=0; c<numCategories; c++)
+          {
           mObjectIndices[c] = new int[numInCategory[c]];
           String cat = categories[c];
           int index = 0;
           for(int o=0; o<numObjects; o++)
             if( data[o].equals(cat) ) mObjectIndices[c][index++] = o;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildSortInt(int[] data)
+        {
         int numObjects = data.length;
         int[] sorted = new int[numObjects];
         System.arraycopy(data, 0, sorted, 0, numObjects);
         Arrays.sort(sorted);
         int[] categories = new int[numObjects];
         int numCategories = 0;
         for(int o=0; o<numObjects; o++)
           if( o==0 || sorted[o-1]!=sorted[o] )
+            {
             categories[numCategories] = sorted[o];
             numCategories++;
+            }
         int lastChange = -1;
         int curr = 0;
         int[] numInCategory = new int[numCategories];
         for(int o=0; o<numObjects; o++)
           if( o==numObjects-1 || sorted[o]!=sorted[o+1] )
+            {
             numInCategory[curr] = o-lastChange;
             curr++;
             lastChange = o;
+            }
         mObjectIndices = new int[numCategories][];
         for(int c=0; c<numCategories; c++)
+          {
           mObjectIndices[c] = new int[numInCategory[c]];
           int cat = categories[c];
           int index = 0;
           for(int o=0; o<numObjects; o++)
             if( data[o]==cat ) mObjectIndices[c][index++] = o;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildSortFloat(float[] data)
+        {
         int numObjects = data.length;
         float[] sorted = new float[numObjects];
         System.arraycopy(data, 0, sorted, 0, numObjects);
         Arrays.sort(sorted);
         float[] categories = new float[numObjects];
         int numCategories = 0;
         for(int o=0; o<numObjects; o++)
           if( o==0 || sorted[o-1]!=sorted[o] )
+            {
             categories[numCategories] = sorted[o];
             numCategories++;
+            }
         int lastChange = -1;
         int curr = 0;
         int[] numInCategory = new int[numCategories];
         for(int o=0; o<numObjects; o++)
           if( o==numObjects-1 || sorted[o]!=sorted[o+1] )
+            {
             numInCategory[curr] = o-lastChange;
             curr++;
             lastChange = o;
+            }
         mObjectIndices = new int[numCategories][];
         for(int c=0; c<numCategories; c++)
+          {
           mObjectIndices[c] = new int[numInCategory[c]];
           float cat = categories[c];
           int index = 0;
           for(int o=0; o<numObjects; o++)
             if( data[o]==cat ) mObjectIndices[c][index++] = o;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildSortCategory()
+        {
         int numObjects = RubikObjectList.getNumObjects();
         int[] cats = new int[numObjects];
         for(int o=0; o<numObjects; o++)
+          {
           RubikObject obj = RubikObjectList.getObject(o);
           cats[o] = obj==null ? 0 : obj.getCategory();
+          }
         buildSortInt(cats);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildSortDifficulty()
+        {
         int numObjects = RubikObjectList.getNumObjects();
         float[] diffs = new float[numObjects];
         for(int o=0; o<numObjects; o++)
+          {
           RubikObject obj = RubikObjectList.getObject(o);
           diffs[o] = obj==null ? 0 : obj.getDifficulty();
+          }
         buildSortFloat(diffs);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildSortAuthor()
+        {
         int numObjects = RubikObjectList.getNumObjects();
         String[] auths = new String[numObjects];
         for(int o=0; o<numObjects; o++)
+          {
           RubikObject obj = RubikObjectList.getObject(o);
           auths[o] = obj==null ? "" : obj.getAuthor();
+          }
         buildSortStr(auths);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildSortYear()
+        {
         int numObjects = RubikObjectList.getNumObjects();
         int[] years = new int[numObjects];
         for(int o=0; o<numObjects; o++)
+          {
           RubikObject obj = RubikObjectList.getObject(o);
           years[o] = obj==null ? 0 : obj.getYearOfInvention();
+          }
         buildSortInt(years);
         buildTitle();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildIconsCategory()
+        {
         mIconIDs = new int[mNumCategories];
         for(int t=0; t<mNumCategories; t++)
+          {
           int obj = mObjectIndices[t][0];
           RubikObject object = RubikObjectList.getObject(obj);
           int category = object==null ? 0 : object.getCategory();
           mIconIDs[t] = CATEGORY_IMAGES[category%5];  //TODO
+          }
+        }
       abstract void buildIndices();
       abstract void buildTitle();
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildIconsDifficulty()
       public static RubikObjectCategories create(int sortMode)
+        {
         mIconIDs = new int[mNumCategories];
         for(int t=0; t<mNumCategories; t++)
+          {
           int obj = mObjectIndices[t][0];
           RubikObject object = RubikObjectList.getObject(obj);
           int difficulty = object==null ? 0 : (int)object.getDifficulty();
           mIconIDs[t] = DIFF_IMAGES[difficulty];
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildTitleAuthor()
+        {
         mTitles = new String[mNumCategories];
         for(int t=0; t<mNumCategories; t++)
         switch(sortMode)
+          {
           int obj = mObjectIndices[t][0];
           RubikObject object = RubikObjectList.getObject(obj);
           mTitles[t] = object==null ? "" : object.getAuthor();
           case SORT_CATEGORY  : return new RubikObjectCategoriesCat();
           case SORT_DIFFICULTY: return new RubikObjectCategoriesDiff();
           case SORT_AUTHOR    : return new RubikObjectCategoriesAuthor();
           case SORT_YEAR      : return new RubikObjectCategoriesYear();
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildTitleYear()
+        {
         mTitles = new String[mNumCategories];
         for(int t=0; t<mNumCategories; t++)
+          {
           int obj = mObjectIndices[t][0];
           RubikObject object = RubikObjectList.getObject(obj);
           int year = object==null ? 0 : object.getYearOfInvention();
           mTitles[t] = year==0 ? "Unknown" : String.valueOf(year);
+          }
         android.util.Log.e("D", "sortMode = "+sortMode+" not implemented!");
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           for(int object : mObjectIndices[c])
             if( object==objectIndex ) return c;
         android.util.Log.e("D", "returning category -1: index: "+objectIndex);
         return -1;
+        }

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision 48e61813

Added by Leszek Koltunski 4 months ago