/ - Diff - Magic Cube - Distorted Android

         tabLayout.setupWithViewPager(viewPager);
         viewPager.setCurrentItem(curTab);
         RubikObjectList list;
         for (int i = 0; i< RubikObjectList.LENGTH; i++)
         for (int object=0; object<RubikObjectList.NUM_OBJECTS; object++)
+          {
           ImageView imageView = new ImageView(act);
           imageView.setImageResource(RubikObjectList.getObject(i).getIconID());
           TabLayout.Tab tab = tabLayout.getTabAt(i);
           if(tab!=null) tab.setCustomView(imageView);
           list = RubikObjectList.getObject(object);
           int[] iconID = list.getIconIDs();
           int len = list.getSizes().length;
           for(int size=0; size<len; size++)
+            {
             int t = RubikObjectList.pack(object,size);
             ImageView imageView = new ImageView(act);
             imageView.setImageResource(iconID[size]);
             TabLayout.Tab tab = tabLayout.getTabAt(t);
             if(tab!=null) tab.setCustomView(imageView);
+            }
+          }
         return builder.create();

src/main/java/org/distorted/dialog/RubikDialogScoresPagerAdapter.java
28	28	import android.widget.LinearLayout;
29	29
30	30	import org.distorted.network.RubikScoresDownloader;
31		import static org.distorted.object.RubikObjectList.LENGTH;
	31	import org.distorted.object.RubikObjectList;
	32
32	33	import static org.distorted.uistate.RubikStatePlay.MAX_SCRAMBLE;
33	34
34	35	///////////////////////////////////////////////////////////////////////////////////////////////////
...	...
38	39	private FragmentActivity mAct;
39	40	private RubikDialogScoresView[] mViews;
40	41	private ViewPager mViewPager;
	42	private int mNumTabs;
41	43
42	44	///////////////////////////////////////////////////////////////////////////////////////////////////
43	45
...	...
49	51
50	52	addPage(mViews[c],country[c],name[c],time[c]);
51	53
52		for(int i=0; i<LENGTH; i++)
	54	for(int i=0; i<mNumTabs; i++)
53	55	{
54	56	if( i==c ) continue;
55	57
...	...
66	68	@Override
67	69	public void run()
68	70	{
69		for(int i=0; i<LENGTH; i++)
	71	for(int i=0; i<mNumTabs; i++)
70	72	{
71	73	mViews[i].prepareView(mAct);
72	74	}
...	...
119	121	@Override
120	122	public void run()
121	123	{
122		for(int i=0; i<LENGTH; i++)
	124	for(int i=0; i<mNumTabs; i++)
123	125	{
124	126	mViews[i].exception(exce);
125	127	}
...	...
132	134	RubikDialogScoresPagerAdapter(FragmentActivity act, ViewPager viewPager)
133	135	{
134	136	mAct = act;
135		mViews = new RubikDialogScoresView[LENGTH];
	137	mNumTabs = RubikObjectList.getTotal();
	138	mViews = new RubikDialogScoresView[mNumTabs];
136	139	mViewPager = viewPager;
137	140
138	141	viewPager.setAdapter(this);
139		viewPager.setOffscreenPageLimit(LENGTH-1);
	142	viewPager.setOffscreenPageLimit(mNumTabs-1);
140	143	}
141	144
142	145	///////////////////////////////////////////////////////////////////////////////////////////////////
...	...
150	153
151	154	boolean allCreated = true;
152	155
153		for(int i=0; i<LENGTH; i++)
	156	for(int i=0; i<mNumTabs; i++)
154	157	{
155	158	if( mViews[i]==null )
156	159	{
...	...
181	184	@Override
182	185	public int getCount()
183	186	{
184		return LENGTH;
	187	return mNumTabs;
185	188	}
186	189
187	190	///////////////////////////////////////////////////////////////////////////////////////////////////

           restorePreferences();
           RubikState.setState(this);
           RubikStatePlay play = (RubikStatePlay)RubikState.PLAY.getStateClass();
           int ordinal = play.getButton();
           view.getRenderer().createObject(RubikObjectList.getObject(ordinal));
           int object = play.getObject();
           int size   = play.getSize();
           RubikObjectList obj = RubikObjectList.getObject(object);
           int objectSize = obj.getSizes()[size];
           view.getRenderer().createObject( obj, objectSize );
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+          {
           int id = v.getId();
           if( id>=0 && id< RubikObjectList.LENGTH )
           if( id>=0 && id< RubikObjectList.getTotal() )
+            {
             RubikObjectList object = RubikObjectList.getObject(id);
             int object = RubikObjectList.unpackObject(id);
             int size= RubikObjectList.unpackSize(id);
             RubikObjectList obj = RubikObjectList.getObject(object);
             int objectSize = obj.getSizes()[size];
             RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);
             boolean success = view.getRenderer().createObject(object);
             boolean success = view.getRenderer().createObject(obj,objectSize);
             if( success )
+              {
               RubikStatePlay play = (RubikStatePlay)RubikState.PLAY.getStateClass();
               play.markButton(this,id);
               play.markButton(this,object,size);
+              }
+            }
-...
         public void Scores(View v)
+          {
           RubikStatePlay play = (RubikStatePlay) RubikState.PLAY.getStateClass();
           int tab = play.getButton();
           int object = play.getObject();
           int size   = play.getSize();
           Bundle bundle = new Bundle();
           bundle.putInt("tab", tab);
           bundle.putInt("tab", RubikObjectList.pack(object,size) );
           RubikDialogScores scores = new RubikDialogScores();
           scores.setArguments(bundle);

         private RubikSurfaceView mView;
         private DistortedScreen mScreen;
         private RubikObjectList mNextObject;
         private int mNextSize;
         private int mScrambleObjectNum;
         private long mRotationFinishedID;
         private long[] mEffectID;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        private void createObjectNow(RubikObjectList object)
        private void createObjectNow(RubikObjectList object, int size)
+         {
          boolean firstTime = (mNewObject==null);
          if( mOldObject!=null ) mOldObject.releaseResources();
          mOldObject = mNewObject;
          mNewObject = object.create(mView.getQuatCurrent(), mView.getQuatAccumulated());
          mNewObject = object.create(size, mView.getQuatCurrent(), mView.getQuatAccumulated());
          mNewObject.createTexture();
          mView.setMovement(object.getObjectMovementClass());
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        boolean createObject(RubikObjectList object)
        boolean createObject(RubikObjectList object, int size)
+         {
          if( mCanDrag && mCanRotate && object!=mNextObject )
          if( mCanDrag && mCanRotate && (object!=mNextObject || mNextSize!=size) && size>0 )
+           {
            mChangeObject = true;
            mNextObject = object;
            mNextSize   = size;
            return true;
+           }
-...
            mCanDrag      = false;
            mCanRotate    = false;
            mCanUI        = false;
            createObjectNow(mNextObject);
            createObjectNow(mNextObject, mNextSize);
            doEffectNow( BaseEffect.Type.SIZECHANGE );
+           }

     package org.distorted.network;
     import org.distorted.object.RubikObjectList;
     import java.io.InputStream;
     import java.net.HttpURLConnection;
     import java.net.URL;
     import java.net.UnknownHostException;
     import static org.distorted.object.RubikObjectList.LENGTH;
     import static org.distorted.uistate.RubikStatePlay.MAX_SCRAMBLE;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       private static String mUserName, mVersion;
       private static int mNumRuns;
       private static int mTotal = RubikObjectList.getTotal();
       private static String mScores = "";
       private static String[][][] mCountry = new String[LENGTH][MAX_SCRAMBLE][MAX_PLACES];
       private static String[][][] mName    = new String[LENGTH][MAX_SCRAMBLE][MAX_PLACES];
       private static String[][][] mTime    = new String[LENGTH][MAX_SCRAMBLE][MAX_PLACES];
       private static String[][][] mCountry = new String[mTotal][MAX_SCRAMBLE][MAX_PLACES];
       private static String[][][] mName    = new String[mTotal][MAX_SCRAMBLE][MAX_PLACES];
       private static String[][][] mTime    = new String[mTotal][MAX_SCRAMBLE][MAX_PLACES];
       private static int[][] mPlaces = new int[LENGTH][MAX_SCRAMBLE];
       private static int[][] mPlaces = new int[mTotal][MAX_SCRAMBLE];
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        {
         int begin=-1 ,end, len = mScores.length();
         for(int i=0; i<LENGTH; i++)
         for(int i=0; i<mTotal; i++)
           for(int j=0; j<MAX_SCRAMBLE; j++)
+            {
             mPlaces[i][j] = 0;
-...
         if( s5>s4 && s4>s3 && s3>s2 && s2>s1 && s1>0 )
+          {
           int size = Integer.valueOf( row.substring(0,s1) );
           int size = Integer.parseInt( row.substring(0,s1) );
           if( size>=0 && size<LENGTH )
           if( size>=0 && size<mTotal )
+            {
             int level      = Integer.valueOf( row.substring(s1+1,s2) );
             int place      = Integer.valueOf( row.substring(s2+1,s3) );
             int level      = Integer.parseInt( row.substring(s1+1,s2) );
             int place      = Integer.parseInt( row.substring(s2+1,s3) );
             String name    = row.substring(s3+1, s4);
             int time       = Integer.valueOf( row.substring(s4+1,s5) );
             int time       = Integer.parseInt( row.substring(s4+1,s5) );
             String country = row.substring(s5+1, s6);
             String realTime= String.valueOf(time/10.0f);

src/main/java/org/distorted/object/RubikCube.java
80	80
81	81	RubikCube(int size, Static4D quatCur, Static4D quatAcc, DistortedTexture texture, MeshRectangles mesh, DistortedEffects effects)
82	82	{
83		super(size,quatCur,quatAcc,texture,mesh,effects);
	83	super(size, 60, quatCur,quatAcc,texture,mesh,effects);
84	84	}
85	85
86	86	///////////////////////////////////////////////////////////////////////////////////////////////////

src/main/java/org/distorted/object/RubikObject.java
73	73
74	74	///////////////////////////////////////////////////////////////////////////////////////////////////
75	75
76		RubikObject(int size, Static4D quatCur, Static4D quatAcc, DistortedTexture nodeTexture, MeshRectangles nodeMesh, DistortedEffects nodeEffects)
	76	RubikObject(int size, int fov, Static4D quatCur, Static4D quatAcc, DistortedTexture nodeTexture, MeshRectangles nodeMesh, DistortedEffects nodeEffects)
77	77	{
78	78	super(nodeTexture,nodeEffects,nodeMesh);
79	79
...	...
122	122	attach(mCubits[i].mNode);
123	123	}
124	124
125		setProjection(30, 0.1f);
	125	setProjection(fov, 0.1f);
126	126	}
127	127
128	128	///////////////////////////////////////////////////////////////////////////////////////////////////

     public enum RubikObjectList
+      {
       CUBE2 ( 2, R.drawable.cube2, RubikCube.class, RubikCubeMovement.class),
       CUBE3 ( 3, R.drawable.cube3, RubikCube.class, RubikCubeMovement.class),
       CUBE4 ( 4, R.drawable.cube4, RubikCube.class, RubikCubeMovement.class),
       CUBE5 ( 5, R.drawable.cube5, RubikCube.class, RubikCubeMovement.class),
       CUBE     ( new int[] {2,3,4},
                  new int[] {R.drawable.cube2,R.drawable.cube3,R.drawable.cube4},
                  new RubikCubeMovement() ),
       PYRAMINX ( new int[] {3,4},
                  new int[] {R.drawable.pyra3,R.drawable.pyra4},
                  new RubikPyraminxMovement() ),
+      ;
       public static final int LENGTH = values().length;
       private final int mObjectSize, mIconID;
       final Class<? extends RubikObject> mObjectClass;
       final Class<? extends RubikObjectMovement> mObjectMovementClass;
       public static final int NUM_OBJECTS = values().length;
       public static final int MAX_SIZE;
       private final int[] mObjectSizes, mIconIDs;
       final RubikObjectMovement mObjectMovementClass;
       private static final RubikObjectList[] objects;
       private static int mNumAll;
       static
+        {
         int i = 0;
         objects = new RubikObjectList[LENGTH];
         mNumAll = 0;
         int size, i = 0;
         objects = new RubikObjectList[NUM_OBJECTS];
         int maxsize = Integer.MIN_VALUE;
         for(RubikObjectList size: RubikObjectList.values())
         for(RubikObjectList object: RubikObjectList.values())
+          {
           objects[i] = size;
           objects[i] = object;
           i++;
           size = object.mObjectSizes.length;
           mNumAll += size;
           if( size> maxsize ) maxsize = size;
+          }
         MAX_SIZE = maxsize;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       RubikObjectList(int size, int iconID, Class<? extends RubikObject > object, Class<? extends RubikObjectMovement> movement)
       public static int pack(int object, int size)
+        {
         int ret = 0;
         for(int i=0; i<object; i++) ret += objects[i].mObjectSizes.length;
         return ret+size;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static int unpackSize(int number)
+        {
         int num;
         for(int i=0; i<NUM_OBJECTS; i++)
+          {
           num = objects[i].mObjectSizes.length;
           if( number<num ) return number;
           number -= num;
+          }
         return -1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static int unpackObject(int number)
+        {
         mObjectSize = size;
         mIconID     = iconID;
         mObjectClass= object;
         int num;
         for(int i=0; i<NUM_OBJECTS; i++)
+          {
           num = objects[i].mObjectSizes.length;
           if( number<num ) return i;
           number -= num;
+          }
         return -1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static int getTotal()
+        {
         return mNumAll;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       RubikObjectList(int[] sizes, int[] iconIDs, RubikObjectMovement movement)
+        {
         mObjectSizes= sizes;
         mIconIDs    = iconIDs;
         mObjectMovementClass = movement;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getIconID()
       public int[] getIconIDs()
+        {
         return mIconID;
         return mIconIDs;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TODO - currently all objects in the list are RubikCubes of various sizes
       public RubikObject create(Static4D quatCur, Static4D quatAcc)
       public int[] getSizes()
+        {
         return mObjectSizes;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public RubikObject create(int size, Static4D quatCur, Static4D quatAcc)
+        {
         DistortedTexture texture = new DistortedTexture();
         DistortedEffects effects = new DistortedEffects();
         MeshRectangles mesh      = new MeshRectangles(20,20);   // mesh of the node, not of the cubits
         return new RubikPyraminx(mObjectSize, quatCur, quatAcc, texture, mesh, effects);
         switch(ordinal())
+          {
           case 0: return new RubikCube    (size, quatCur, quatAcc, texture, mesh, effects);
           case 1: return new RubikPyraminx(size, quatCur, quatAcc, texture, mesh, effects);
+          }
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TODO - currently all objects in the list are RubikCubes of various sizes
       public RubikObjectMovement getObjectMovementClass()
+        {
         return new RubikPyraminxMovement();
         return mObjectMovementClass;
+        }
+      }

src/main/java/org/distorted/object/RubikPyraminx.java
85	85
86	86	RubikPyraminx(int size, Static4D quatCur, Static4D quatAcc, DistortedTexture texture, MeshRectangles mesh, DistortedEffects effects)
87	87	{
88		super(size,quatCur,quatAcc,texture,mesh,effects);
	88	super(size, 30, quatCur,quatAcc,texture,mesh,effects);
89	89	}
90	90
91	91	///////////////////////////////////////////////////////////////////////////////////////////////////

       private static final int MIN_SCRAMBLE =  1;
       private static final int DEF_SCRAMBLE =  1;
       public  static final int MAX_SCRAMBLE = 18;
       private static final int DEF_BUTTON   = RubikObjectList.CUBE3.ordinal();
       private static final int DEF_OBJECT   = RubikObjectList.CUBE.ordinal();
       private static final int DEF_SIZE     =  1;  // i.e. the second from the list of CUBE's sizes
       private HorizontalNumberPicker mPicker;
       private int mPickerValue;
       private int mButton = DEF_BUTTON;
       private int mObject = DEF_OBJECT;
       private int mSize   = DEF_SIZE;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         int padding = (int)(3*scale + 0.5f);
         ViewGroup.LayoutParams params = new ViewGroup.LayoutParams(size,size);
         for(int i = 0; i< RubikObjectList.LENGTH; i++)
         for(int i=0; i< RubikObjectList.NUM_OBJECTS; i++)
+          {
           ImageButton button = new ImageButton(act);
           button.setLayoutParams(params);
           button.setId(i);
           button.setPadding(padding,0,padding,0);
           int iconID = RubikObjectList.getObject(i).getIconID();
           button.setImageResource(iconID);
           button.setOnClickListener(act);
           layoutBot.addView(button);
           int[] iconIDs = RubikObjectList.getObject(i).getIconIDs();
           int len = iconIDs.length;
           for(int s=0; s<len; s++)
+            {
             ImageButton button = new ImageButton(act);
             button.setLayoutParams(params);
             button.setId(RubikObjectList.pack(i,s));
             button.setPadding(padding,0,padding,0);
             button.setImageResource(iconIDs[s]);
             button.setOnClickListener(act);
             layoutBot.addView(button);
+            }
+          }
         ViewGroup.LayoutParams params2 = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,size);
-...
         button.setOnClickListener(act);
         layoutBot.addView(button);
         markButton(act,mButton);
         markButton(act,mObject,mSize);
         mPicker = act.findViewById(R.id.rubikNumberPicker);
-...
+        {
         if( mPicker!=null )
+          {
           editor.putInt("scramble", mPicker.getValue() );
           editor.putInt("statePlay_scramble", mPicker.getValue() );
+          }
         editor.putInt("button", mButton);
         editor.putInt("statePlay_object", mObject);
         editor.putInt("statePlay_size"  , mSize);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void restorePreferences(SharedPreferences preferences)
+        {
         mPickerValue= preferences.getInt("scramble", DEF_SCRAMBLE);
         mButton     = preferences.getInt("button"  , DEF_BUTTON  );
         mPickerValue= preferences.getInt("statePlay_scramble", DEF_SCRAMBLE);
         mObject     = preferences.getInt("statePlay_object"  , DEF_OBJECT  );
         mSize       = preferences.getInt("statePlay_size"    , DEF_SIZE    );
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getButton()
       public int getObject()
+        {
         return mButton;
         return mObject;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void markButton(RubikActivity act, int button)
       public int getSize()
+        {
         mButton = button;
         return mSize;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void markButton(RubikActivity act, int object, int size)
+        {
         mObject = object;
         mSize   = size;
         int lookingFor = RubikObjectList.pack(object,size);
         int len = RubikObjectList.getTotal();
         for(int b = 0; b< RubikObjectList.LENGTH; b++)
         for(int button=0; button<len; button++)
+          {
           Drawable d = act.findViewById(b).getBackground();
           Drawable d = act.findViewById(button).getBackground();
           if( b==button )
           if( button==lookingFor )
+            {
             d.setColorFilter(ContextCompat.getColor(act,R.color.red), PorterDuff.Mode.MULTIPLY);
+            }

     import org.distorted.magic.R;
     import org.distorted.magic.RubikActivity;
     import org.distorted.object.RubikObjectList;
     import java.util.Timer;
     import java.util.TimerTask;
     import static android.view.View.INVISIBLE;
     import static org.distorted.object.RubikObjectList.LENGTH;
     import static org.distorted.object.RubikObjectList.NUM_OBJECTS;
     import static org.distorted.object.RubikObjectList.MAX_SIZE;
     import static org.distorted.uistate.RubikStatePlay.MAX_SCRAMBLE;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       private long mStartTime;
       private boolean mRunning;
       private long[][] mRecords;
       private long[][][] mRecords;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       RubikStateSolving()
+        {
         mRecords = new long[LENGTH][MAX_SCRAMBLE];
         mRecords = new long[NUM_OBJECTS][MAX_SIZE][MAX_SCRAMBLE];
         for(int i=0; i<LENGTH; i++)
           for(int j=0; j<MAX_SCRAMBLE; j++)
+            {
             mRecords[i][j] = NO_RECORD;
+            }
         for(int i=0; i<NUM_OBJECTS; i++)
           for(int j=0; j<MAX_SIZE; j++)
             for(int k=0; k<MAX_SCRAMBLE; k++)
+              {
               mRecords[i][j][k] = NO_RECORD;
+              }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public void savePreferences(SharedPreferences.Editor editor)
+        {
         for(int i=0; i<LENGTH; i++)
           for(int j=0; j<MAX_SCRAMBLE; j++)
+            {
             if( mRecords[i][j]!=NO_RECORD)
         for(int i=0; i<NUM_OBJECTS; i++)
           for(int j=0; j<MAX_SIZE; j++)
             for(int k=0; k<MAX_SCRAMBLE; k++)
+              {
               editor.putLong("record_"+i+"_"+j, mRecords[i][j]);
               if( mRecords[i][j][k]!=NO_RECORD)
+                {
                 editor.putLong("record_"+i+"_"+j+"_"+k, mRecords[i][j][k]);
+                }
+              }
+            }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void restorePreferences(SharedPreferences preferences)
+        {
         for(int i=0; i<LENGTH; i++)
           for(int j=0; j<MAX_SCRAMBLE; j++)
+            {
             mRecords[i][j] = preferences.getLong("record_"+i+"_"+j, NO_RECORD );
+            }
         for(int i=0; i<NUM_OBJECTS; i++)
           for(int j=0; j<MAX_SIZE; j++)
             for(int k=0; k<MAX_SCRAMBLE; k++)
+              {
               mRecords[i][j][k] = preferences.getLong("record_"+i+"_"+j+"_"+k, NO_RECORD );
+              }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
           long timeTaken = System.currentTimeMillis()-mStartTime;
           RubikStatePlay play = (RubikStatePlay)RubikState.PLAY.getStateClass();
           int object  = play.getButton();
           int object  = play.getObject();
           int size    = play.getSize();
           int scramble= play.getPicker();
           int maxsize = RubikObjectList.getObject(object).getSizes().length;
           if( object>=0 && object<LENGTH && scramble>=0 && scramble<MAX_SCRAMBLE )
           if( object>=0 && object< NUM_OBJECTS && size>=0 && size<maxsize && scramble>=0 && scramble<MAX_SCRAMBLE )
+            {
             if( mRecords[object][scramble]> timeTaken )
             if( mRecords[object][size][scramble]> timeTaken )
+              {
               mRecords[object][scramble] = timeTaken;
               mRecords[object][size][scramble] = timeTaken;
               android.util.Log.e("solv","new record!");
+              }
+            }

Project

General

Profile

Magic Cube

Revision 4888e97c

Added by Leszek Koltunski about 4 years ago