/ - Diff - Magic Cube - Distorted Android

src/main/java/org/distorted/bandaged/BandagedRenderer.java
304	304	try
305	305	{
306	306	JsonWriter writer = JsonWriter.getInstance();
307		String json = writer.createObjectString(object,24,0);
	307	String json = writer.createObjectString(object);
308	308	writer.write(filename,json);
309	309	return true;
310	310	}

     package org.distorted.config;
     import static org.distorted.objects.RubikObjectCategories.DIFF_IDS;
     import static org.distorted.objects.RubikObjectCategories.DIFF_IMAGES;
     import java.io.InputStream;
     import android.graphics.PorterDuff;
-...
     public class ConfigScreenPane
+    {
       private static final int[] IDS =
+        {
         R.id.configDifficulty0,
         R.id.configDifficulty1,
         R.id.configDifficulty2,
         R.id.configDifficulty3,
         R.id.configDifficulty4
         };
       private static final int[] IMAGES =
+        {
         R.drawable.difficulty1,
         R.drawable.difficulty2,
         R.drawable.difficulty3,
         R.drawable.difficulty4,
         R.drawable.difficulty5,
         };
       private static final int NUM_IDS         = IDS.length;
       private static final int NUM_IDS         = DIFF_IDS.length;
       private static final float PADDING_RATIO = 0.016f;
       private static final float TEXT_RATIO    = 0.025f;
-...
+            {
             reader.parseJsonFileMetadata(stream);
             name       = reader.getObjectName();
             author     = reader.getInventor();
             author     = reader.getAuthor();
             year       = reader.getYearOfInvention();
             difficulty = (int)reader.getComplexity();
             difficulty = (int)reader.getDifficulty();
+            }
           catch(Exception ex)
+            {
-...
           for(int i=0; i<NUM_IDS; i++)
+            {
             ImageView image = layout.findViewById(IDS[i]);
             image.setImageResource(IMAGES[i]);
             ImageView image = layout.findViewById(DIFF_IDS[i]);
             image.setImageResource(DIFF_IMAGES[i]);
             image.setColorFilter( difficulty==i ? 0xffff0000 : 0xffffffff, PorterDuff.Mode.MULTIPLY );
+            }
+          }

               File file = new File(act.getFilesDir(), objectName);
               InputStream stream = new FileInputStream(file);
               JsonReader reader = new JsonReader();
               reader.readNumScramblesAndPrice(stream);
               reader.parseJsonFileMetadata(stream);
               stream.close();
               mInfo.mNumScrambles = reader.getNumScrambles();
               mInfo.mPrice        = reader.getPrice();
               float diff          = reader.getDifficulty();
               int category        = reader.getCategory();
               int year            = reader.getYearOfInvention();
               String author       = reader.getAuthor();
               if( SHOW_DOWNLOADED_DEBUG ) android.util.Log.e("D", "Read from JSON numScrambles="+mInfo.mNumScrambles+" price="+mInfo.mPrice);
               if( mInfo.mExtrasStream!=null )
-...
                 if( SHOW_DOWNLOADED_DEBUG ) android.util.Log.e("D", "1");
                 boolean success = RubikObjectList.addDownloadedObject(act, mInfo.mObjectShortName, mInfo.mNumScrambles, mInfo.mPrice,
                                                                       mInfo.mObjectMinorVersion, mInfo.mExtrasMinorVersion, mIconSaved, oSuccess, eSuccess);
                 boolean success = RubikObjectList.addDownloadedObject(act, mInfo.mObjectShortName, mInfo.mNumScrambles, mInfo.mPrice, mInfo.mObjectMinorVersion,
                                                                       mInfo.mExtrasMinorVersion, mIconSaved, oSuccess, eSuccess, diff, category, year, author);
                 if( success )
+                  {
                   if( SHOW_DOWNLOADED_DEBUG ) android.util.Log.e("D", "2");

+          }
         LayoutInflater layoutInflater = (LayoutInflater)act.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
         int obj = 0;
         for(int object : objects)
+          {
           View v = createView(act,layoutInflater,object,mPadding );
           int row = object/colCount;
           int row = obj/colCount;
           obj++;
           GridLayout.Spec rs = rowSpecs[row];
           GridLayout.Spec cs = colSpecs[nextInRow[row]];
           GridLayout.LayoutParams params = new GridLayout.LayoutParams(rowSpecs[row],colSpecs[nextInRow[row]]);
           GridLayout.LayoutParams params = new GridLayout.LayoutParams(rs,cs);
           params.bottomMargin = mMargin;
           params.topMargin    = mMargin;
           params.leftMargin   = mMargin;

       private final int mSolverOrdinal;
       private final int mObjectOrdinal;
       private final boolean mIsLocal;
       private final int mCategory, mYear;
       private final float mDifficulty;
       private final String mAuthor;
       private boolean mIsFree;
       private int mJsonID, mMeshID, mExtrasID;
-...
         mJsonID      = meta.objectJson();
         mMeshID      = meta.mesh();
         mExtrasID    = meta.extrasJson();
         mDifficulty  = meta.getDifficulty();
         mCategory    = meta.getCategory();
         mYear        = meta.getYearOfInvention();
         mAuthor      = meta.getAuthor();
         mIsLocal     = false;
         int patternOrdinal  = RubikPatternList.getOrdinal(mObjectOrdinal);
-...
         mIsFree        = mPrice==0;
         mObjectVersion = object.objectVersion;
         mExtrasVersion = object.extrasVersion;
         mDifficulty    = object.difficulty;
         mCategory      = object.category;
         mYear          = object.year;
         mAuthor        = object.author;
         mPatterns      = null;
         mExtrasOrdinal = -1;
-...
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getCategory()
+        {
         return mCategory;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public float getDifficulty()
+        {
         return mDifficulty;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention()
+        {
         return mYear;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public String getAuthor()
+        {
         return mAuthor;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public boolean hasExtras()

     import static org.distorted.main.MainSettingsPopup.*;
     import org.distorted.main.R;
     import java.util.Arrays;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     public class RubikObjectCategories
+    {
       public static final int[] DIFF_IDS =
+        {
         R.id.configDifficulty0,
         R.id.configDifficulty1,
         R.id.configDifficulty2,
         R.id.configDifficulty3,
         R.id.configDifficulty4
         };
       public static final int[] DIFF_IMAGES =
+        {
         R.drawable.difficulty1,
         R.drawable.difficulty2,
         R.drawable.difficulty3,
         R.drawable.difficulty4,
         R.drawable.difficulty5,
         };
       public static final int[] CATEGORY_IMAGES =
+        {
         R.drawable.difficulty1,
         R.drawable.difficulty2,
         R.drawable.difficulty3,
         R.drawable.difficulty4,
         R.drawable.difficulty5,
         };
       private final int mNumCategories;
       private int[][] mObjectIndices;
       private int[] mIconIDs;
-...
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       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);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       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
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void buildIconsDifficulty()
+        {
         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];
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+          {
           int obj = mObjectIndices[t][0];
           RubikObject object = RubikObjectList.getObject(obj);
           mTitles[t] = object==null ? "" : object.getAuthor();
+          }
+        }
-...
       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] = String.valueOf(year);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

         String shortName;
         boolean icon,object,extras;
         int numScrambles, objectVersion, extrasVersion, price;
         int category, year;
         float difficulty;
         String author;
         DownloadedObject(String sName, int scrambles, int pr, int oVersion, int eVersion, boolean i, boolean o, boolean e)
         DownloadedObject(String sName, int scrambles, int pr, int oVersion, int eVersion, boolean i,
                          boolean o, boolean e, float diff, int cat, int y, String a)
+          {
           shortName     = sName;
           numScrambles  = scrambles;
           price         = pr;
           objectVersion = oVersion;
           extrasVersion = eVersion;
           difficulty    = diff;
           category      = cat;
           year          = y;
           author        = a;
           icon   = i;
           object = o;
-...
     // PUBLIC API
       public static boolean addDownloadedObject(Context context, String shortName, int numScrambles, int price, int objectVersion,
                                              int extrasVersion, boolean icon, boolean object, boolean extras)
                                              int extrasVersion, boolean icon, boolean object, boolean extras, float diff, int category, int year, String author)
+        {
         if( SHOW_DOWNLOADED_DEBUG ) android.util.Log.e("D", "New downloaded object "+shortName+" icon="+icon+" object="+object+" extras="+extras);
-...
         if( !object ) objectVersion=-1;
         if( !extras ) extrasVersion=-1;
         DownloadedObject obj = new DownloadedObject(shortName,numScrambles,price,objectVersion,extrasVersion,icon,object,extras);
         DownloadedObject obj = new DownloadedObject(shortName,numScrambles,price,objectVersion,extrasVersion,icon,object,extras,diff,category,year,author);
         if ( internalAddDownloadedObject(obj) )
+          {
           if( SHOW_DOWNLOADED_DEBUG ) android.util.Log.e("D", "Adding new downloaded object "+shortName+" icon="+obj.icon+" object="+obj.object+" extras="+obj.extras);
-...
             downloadedObjects.append(' ');
             downloadedObjects.append(object.extras ? "1":"0");
             downloadedObjects.append(' ');
             downloadedObjects.append(object.difficulty);
             downloadedObjects.append(' ');
             downloadedObjects.append(object.category);
             downloadedObjects.append(' ');
             downloadedObjects.append(object.year);
             downloadedObjects.append(' ');
             downloadedObjects.append(object.author);
             downloadedObjects.append(' ');
             downloadedObjects.append(object.price);
+            }
-...
             String[] parts = dObj.split(" ");
             int length = parts.length;
             if( length==7 || length==8 )
             if( length>=7 )
+              {
               String name = parts[0];
               String scra = parts[1];
-...
               String obje = parts[5];
               String extr = parts[6];
               int price;
               int price=0,category=0,year=0;
               float diff=0.0f;
               String author="";
               if( length==7 ) price=0;
               else
               if( length>=11 )
+                {
                 diff     = Float.parseFloat(parts[7]);
                 category = Integer.parseInt(parts[8]);
                 year     = Integer.parseInt(parts[9]);
                 author   = parts[10];
+                }
               if( length>=12 )
+                {
                 char c = parts[7].charAt(0);
                 char c = parts[11].charAt(0);
                 if( c=='t' )      price = 0;
                 else if( c=='f' ) price = ListObjects.DEFAULT_PRICE_OF_OLD_OBJECTS;
                 else              price = Integer.parseInt(parts[7]);
-...
               boolean bObje = obje.equals("1");
               boolean bExtr = extr.equals("1");
               addDownloadedObject(context,name,scrambles,price,oVersion,eVersion,bIcon,bObje,bExtr);
               addDownloadedObject(context,name,scrambles,price,oVersion,eVersion,bIcon,bObje,bExtr,diff,category,year,author);
+              }
+            }
+          }

src/main/java/org/distorted/purchase/PurchaseScreenPane.java
189	189	{
190	190	reader.parseJsonFileMetadata(stream);
191	191	name = reader.getObjectName();
192		author = reader.getInventor();
	192	author = reader.getAuthor();
193	193	year = reader.getYearOfInvention();
194		difficulty = (int)reader.getComplexity();
	194	difficulty = (int)reader.getDifficulty();
195	195	}
196	196	catch(Exception ex)
197	197	{

Project

General

Profile

Magic Cube

Revision ff4a2a13

Added by Leszek Koltunski almost 2 years ago