/ - Diff - TwistyPuzzleLib - Distorted Android

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Copyright 2021 Leszek Koltunski                                                               //
     //                                                                                               //
     // This file is part of Distorted.                                                               //
     //                                                                                               //
     // Distorted is free software: you can redistribute it and/or modify                             //
     // it under the terms of the GNU General Public License as published by                          //
     // the Free Software Foundation, either version 2 of the License, or                             //
     // (at your option) any later version.                                                           //
     //                                                                                               //
     // Distorted is distributed in the hope that it will be useful,                                  //
     // but WITHOUT ANY WARRANTY; without even the implied warranty of                                //
     // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //
     // GNU General Public License for more details.                                                  //
     //                                                                                               //
     // You should have received a copy of the GNU General Public License                             //
     // along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     package org.distorted.objectlib.json;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.helpers.ObjectShape;
     import org.distorted.objectlib.helpers.ObjectSticker;
     import org.distorted.objectlib.helpers.ScrambleState;
     import org.json.JSONArray;
     import org.json.JSONException;
     import org.json.JSONObject;
     import org.distorted.objectlib.main.TwistyObject;
     import org.distorted.objectlib.main.ObjectType;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     public class JsonWriter
+    {
       private static final int VERSION_MAJOR = 1;
       private static final int VERSION_MINOR = 0;
       private static JsonWriter mThis;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JsonWriter()
+        {
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONArray generateCubits(TwistyObject object) throws JSONException
+        {
         JSONArray array = new JSONArray();
         int[] numLayers     = object.getNumLayers();
         float[][] positions = object.getCubitPositions(numLayers);
         int numCubits = positions.length;
         int numFaces = object.getNumCubitFaces();
         for(int i=0; i<numCubits; i++)
+          {
           JSONObject cubit = new JSONObject();
           Static4D rotQuat  = object.getQuat(i,numLayers);
           int variant       = object.getCubitVariant(i,numLayers);
           int[] solvedQuats = object.getSolvedQuats(i,numLayers);
           JSONArray pos = new JSONArray();
           int numPos = positions[i].length;
           for(int j=0; j<numPos; j++) pos.put(positions[i][j]);
           cubit.put("centers", pos);
           cubit.put("qx", rotQuat.get0() );
           cubit.put("qy", rotQuat.get1() );
           cubit.put("qz", rotQuat.get2() );
           cubit.put("qw", rotQuat.get3() );
           cubit.put("variant", variant );
           if( solvedQuats!=null )
+            {
             JSONArray solved = new JSONArray();
             for (int solvedQuat : solvedQuats) solved.put(solvedQuat);
             cubit.put("solvedQuats",solved);
+            }
           JSONArray colors = new JSONArray();
           for(int j=0; j<numFaces; j++)
+            {
             int cubColor = object.getCubitFaceColor(i,j,numLayers);
             colors.put(cubColor);
+            }
           cubit.put("colors",colors);
           array.put(cubit);
+          }
         return array;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONArray generateCorners(float[][] corners) throws JSONException
+        {
         JSONArray array = new JSONArray();
         for(float[] c : corners)
+          {
           JSONObject corner = new JSONObject();
           corner.put("strength", c[0]);
           corner.put("radius"  , c[1]);
           array.put(corner);
+          }
         return array;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONArray generateCenters(float[][] centers) throws JSONException
+        {
         JSONArray array = new JSONArray();
         for(float[] c : centers)
+          {
           JSONObject center = new JSONObject();
           center.put("x", c[0]);
           center.put("y", c[1]);
           center.put("z", c[2]);
           array.put(center);
+          }
         return array;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONArray generateBands(float[][] bands) throws JSONException
+        {
         JSONArray array = new JSONArray();
         for (float[] b : bands)
+          {
           JSONObject band = new JSONObject();
           band.put("height"          , b[0]);
           band.put("angle"           , b[1]);
           band.put("distanceToCenter", b[2]);
           band.put("distanceToFlat"  , b[3]);
           band.put("numOfBands"      , b[4]);
           band.put("extraI"          , b[5]);
           band.put("extraJ"          , b[6]);
           array.put(band);
+          }
         return array;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONArray generateFaces(TwistyObject object, int[][] vertIndices, int[] bandIndices, int cubit, int[] numLayers) throws JSONException
+        {
         JSONArray array = new JSONArray();
         int numFaces = vertIndices.length;
         int variant = object.getCubitVariant(cubit,numLayers);
         for(int i=0; i<numFaces; i++)
+          {
           JSONObject face = new JSONObject();
           face.put("bandIndex", bandIndices[i]);
           int sticker = object.getVariantFaceColor(variant,i,numLayers);
           face.put("sticker",sticker);
           JSONArray vertArr = new JSONArray();
           int numV = vertIndices[i].length;
           for(int j=0; j<numV; j++) vertArr.put(vertIndices[i][j]);
           face.put("vertexIndices",vertArr);
           array.put(face);
+          }
         return array;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONArray generateVertices(double[][] vertices, int[] cornerIndices, int[] centerIndices) throws JSONException
+        {
         JSONArray array = new JSONArray();
         int numVertices = vertices.length;
         for(int j=0; j<numVertices; j++)
+          {
           JSONObject vert = new JSONObject();
           vert.put("x", vertices[j][0]);
           vert.put("y", vertices[j][1]);
           vert.put("z", vertices[j][2]);
           vert.put("cornerIndex", cornerIndices[j]);
           vert.put("centerIndex", centerIndices[j]);
           array.put(vert);
+          }
         return array;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONObject generateConvexity(float[] convexity) throws JSONException
+        {
         JSONObject object = new JSONObject();
         object.put("x", convexity[0]);
         object.put("y", convexity[1]);
         object.put("z", convexity[2]);
         return object;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private int findCubitWithVariant(TwistyObject object, int variant, int numCubits, int[] numLayers)
+        {
         for(int i=0; i<numCubits; i++)
+          {
           if( object.getCubitVariant(i,numLayers)==variant ) return i;
+          }
         return -1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONArray generateShapes(TwistyObject object) throws JSONException
+        {
         JSONArray shapes = new JSONArray();
         int[] numLayers = object.getNumLayers();
         int numVariants = object.getNumCubitVariants(numLayers);
         float[][] positions = object.getCubitPositions(numLayers);
         int numCubits = positions.length;
         for(int i=0; i<numVariants; i++)
+          {
           JSONObject shapeObj = new JSONObject();
           ObjectShape shape = object.getObjectShape(i);
           float[] convexity  = shape.getConvexityCenter();
           double[][] vertices= shape.getVertices();
           int[][] vertIndices= shape.getVertIndices();
           float[][] bands    = shape.getBands();
           int[] bandIndices  = shape.getBandIndices();
           float[][] corners  = shape.getCorners();
           int[] cornerIndices= shape.getCornerIndices();
           float[][] centers  = shape.getCenters();
           int[] centerIndices= shape.getCenterIndices();
           int cubit = findCubitWithVariant(object,i,numCubits,numLayers);
           if( convexity!=null )
+            {
             JSONObject convObj = generateConvexity(convexity);
             shapeObj.put("convexity", convObj);
+            }
           JSONArray verticesArr = generateVertices(vertices,cornerIndices,centerIndices);
           shapeObj.put("vertices", verticesArr);
           JSONArray facesArr = generateFaces(object,vertIndices,bandIndices,cubit,numLayers);
           shapeObj.put("faces", facesArr);
           JSONArray bandsArr = generateBands(bands);
           shapeObj.put("bands", bandsArr);
           JSONArray cornerArr = generateCorners(corners);
           shapeObj.put("cornerPush", cornerArr);
           JSONArray centerArr = generateCenters(centers);
           shapeObj.put("centerPush", centerArr);
           shapes.put(shapeObj);
+          }
         return shapes;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONArray generateStickers(TwistyObject object) throws JSONException
+        {
         JSONArray stickers = new JSONArray();
         int[] numLayers = object.getNumLayers();
         int numStickers = object.getNumStickerTypes(numLayers);
         for(int i=0; i<numStickers; i++)
+          {
           JSONObject stickerObj = new JSONObject();
           JSONArray  vertexArray= new JSONArray();
           ObjectSticker sticker = object.retSticker(i);
           float[] coords     = sticker.getCoords();
           float[] curvatures = sticker.getCurvature();
           float[] radii      = sticker.getRadii();
           float   stroke     = sticker.getStroke();
           stickerObj.put("stroke", stroke);
           int numVertices = radii.length;
           for(int j=0; j<numVertices; j++)
+            {
             JSONObject vertex = new JSONObject();
             vertex.put("x", coords[2*j  ]);
             vertex.put("y", coords[2*j+1]);
             vertex.put("angle", curvatures==null ? 0 : curvatures[j]);
             vertex.put("radius",radii[j]);
             vertexArray.put(vertex);
+            }
           stickerObj.put("vertices", vertexArray);
           stickers.put(stickerObj);
+          }
         return stickers;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONObject generateMesh(TwistyObject object) throws JSONException
+        {
         JSONObject mesh = new JSONObject();
         JSONArray cubits   = generateCubits(object);
         JSONArray shapes   = generateShapes(object);
         JSONArray stickers = generateStickers(object);
         mesh.put("cubits"  , cubits);
         mesh.put("shapes"  , shapes);
         mesh.put("stickers", stickers);
         return mesh;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONObject generateMetadata(TwistyObject object) throws JSONException
+        {
         JSONObject metadata = new JSONObject();
         ObjectType type  = object.getObjectType();
         String inventor  = object.getInventor();
         String shortname = type.name();
         String lowerShort= shortname.toLowerCase();
         String longname  = object.getObjectName();
         metadata.put("longname"     , longname );
         metadata.put("shortname"    , shortname );
         metadata.put("inventor"     , inventor);
         metadata.put("year"         , object.getYearOfInvention());
         metadata.put("complexity"   , object.getComplexity());
         metadata.put("icon_huge"    , "h_"+lowerShort+".png");
         metadata.put("icon_big"     , "b_"+lowerShort+".png");
         metadata.put("icon_medium"  , "m_"+lowerShort+".png");
         metadata.put("icon_small"   , "s_"+lowerShort+".png");
         metadata.put("mesh"         , lowerShort+".dmesh");
         metadata.put("num_scrambles", type.getNumScramble() );
         metadata.put("size"         , object.getSize() );
         metadata.put("solved_func"  , object.getSolvedFunctionIndex() );
         return metadata;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONArray generateQuats(TwistyObject object) throws JSONException
+        {
         JSONArray quatsArray = new JSONArray();
         Static4D[] quats = object.getQuats();
         for(Static4D quat : quats)
+          {
           JSONObject q = new JSONObject();
           q.put("x",quat.get0());
           q.put("y",quat.get1());
           q.put("z",quat.get2());
           q.put("w",quat.get3());
           quatsArray.put(q);
+          }
         return quatsArray;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONArray generateAxis(TwistyObject object) throws JSONException
+        {
         JSONArray axis = new JSONArray();
         Static3D[] rotAxis = object.getRotationAxis();
         int numAxis = rotAxis.length;
         int[] basicAngle = object.getBasicAngle();
         int[] numLayers = object.getNumLayers();
         float[][] cuts = object.getCuts(numLayers);
         boolean[][] rotatable = object.getLayerRotatable(numLayers);
         for( int i=0; i<numAxis; i++ )
+          {
           JSONObject axObject = new JSONObject();
           Static3D ax = rotAxis[i];
           axObject.put("x", ax.get0() );
           axObject.put("y", ax.get1() );
           axObject.put("z", ax.get2() );
           axObject.put("basicAngle", basicAngle[i] );
           JSONArray cutsArray = new JSONArray();
           for(float cut : cuts[i]) cutsArray.put(cut);
           axObject.put("cuts", cutsArray);
           JSONArray rotaArray = new JSONArray();
           for(boolean rot : rotatable[i]) rotaArray.put(rot);
           axObject.put("rotatable", rotaArray );
           axis.put(axObject);
+          }
         return axis;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONObject generateScrambling(TwistyObject object) throws JSONException
+        {
         JSONObject scrambling = new JSONObject();
         ScrambleState[] states = object.getScrambleStates();
         int scrambleType = object.getScrambleType();
         scrambling.put("scrambleType",scrambleType );
         if( states!=null )
+          {
           JSONArray scrambleStates = new JSONArray();
           for(ScrambleState state : states)
+            {
             JSONArray axisArray = new JSONArray();
             int numAxis = state.getNumAxis();
             for(int ax=0; ax<numAxis; ax++)
+              {
               JSONArray axArray = new JSONArray();
               int[] axData = state.getAx(ax);
               if( axData!=null )
                 for(int data : axData) axArray.put(data);
               axisArray.put(axArray);
+              }
             scrambleStates.put(axisArray);
+            }
           scrambling.put("scrambleStates", scrambleStates);
+          }
         return scrambling;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private JSONObject generateTouchControl(TwistyObject object) throws JSONException
+        {
         JSONObject touchControl = new JSONObject();
         touchControl.put("movementType" , object.getMovementType() );
         touchControl.put("movementSplit", object.getMovementSplit() );
         int[][][] enabled = object.getEnabled();
         JSONArray enabledArray = new JSONArray();
         for(int[][] faceEnabled : enabled)
+          {
           JSONArray faceArray = new JSONArray();
           for(int[] sectionEnabled : faceEnabled)
+            {
             JSONArray sectionArray = new JSONArray();
             for(int ax : sectionEnabled) sectionArray.put(ax);
             faceArray.put(sectionArray);
+            }
           enabledArray.put(faceArray);
+          }
         touchControl.put("enabledAxis", enabledArray);
         return touchControl;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public String createJsonString(TwistyObject object) throws JSONException
+        {
         JSONObject json = new JSONObject();
         JSONObject metadata    = generateMetadata(object);
         JSONObject mesh        = generateMesh(object);
         JSONArray  axis        = generateAxis(object);
         JSONArray  quats       = generateQuats(object);
         JSONObject scrambling  = generateScrambling(object);
         JSONObject touchControl= generateTouchControl(object);
         json.put("major"       , VERSION_MAJOR);
         json.put("minor"       , VERSION_MINOR);
         json.put("metadata"    , metadata);
         json.put("mesh"        , mesh);
         json.put("axis"        , axis);
         json.put("quats"       , quats);
         json.put("scrambling"  , scrambling);
         json.put("touchcontrol", touchControl);
         String ret = json.toString();
         android.util.Log.e("D", ret);
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public static JsonWriter getInstance()
+        {
         if( mThis==null ) mThis = new JsonWriter();
         return mThis;
+        }
+    }

       public abstract Static3D[] getRotationAxis();
       public abstract int[] getBasicAngle();
       public abstract int getNumFaces();
       public abstract int getObjectName(int[] numLayers);
       public abstract int getInventor(int[] numLayers);
       public abstract int getYearOfInvention(int[] numLayers);
       public abstract int getComplexity(int[] numLayers);
       public abstract String getObjectName();
       public abstract String getInventor();
       public abstract int getYearOfInvention();
       public abstract int getComplexity();
       public abstract int getFOV();
+      }

src/main/java/org/distorted/objectlib/objects/TwistyBandaged2Bar.java
119	119
120	120	///////////////////////////////////////////////////////////////////////////////////////////////////
121	121
122		public int getObjectName(int[] numLayers)
	122	public String getObjectName()
123	123	{
124		return R.string.bandaged_2bar;
	124	return "2Bar Cube";
125	125	}
126	126
127	127	///////////////////////////////////////////////////////////////////////////////////////////////////
128	128
129		public int getInventor(int[] numLayers)
	129	public String getInventor()
130	130	{
131		return R.string.bandaged_2bar_inventor;
	131	return "unknown";
132	132	}
133	133
134	134	///////////////////////////////////////////////////////////////////////////////////////////////////
135	135
136		public int getYearOfInvention(int[] numLayers)
	136	public int getYearOfInvention()
137	137	{
138	138	return 2000;
139	139	}
140	140
141	141	///////////////////////////////////////////////////////////////////////////////////////////////////
142	142
143		public int getComplexity(int[] numLayers)
	143	public int getComplexity()
144	144	{
145	145	return 8;
146	146	}

src/main/java/org/distorted/objectlib/objects/TwistyBandaged3Plate.java
126	126
127	127	///////////////////////////////////////////////////////////////////////////////////////////////////
128	128
129		public int getObjectName(int[] numLayers)
	129	public String getObjectName()
130	130	{
131		return R.string.bandaged_3plate;
	131	return "Bandaged Cube C";
132	132	}
133	133
134	134	///////////////////////////////////////////////////////////////////////////////////////////////////
135	135
136		public int getInventor(int[] numLayers)
	136	public String getInventor()
137	137	{
138		return R.string.bandaged_3plate_inventor;
	138	return "unknown";
139	139	}
140	140
141	141	///////////////////////////////////////////////////////////////////////////////////////////////////
142	142
143		public int getYearOfInvention(int[] numLayers)
	143	public int getYearOfInvention()
144	144	{
145	145	return 2000;
146	146	}
147	147
148	148	///////////////////////////////////////////////////////////////////////////////////////////////////
149	149
150		public int getComplexity(int[] numLayers)
	150	public int getComplexity()
151	151	{
152	152	return 8;
153	153	}

src/main/java/org/distorted/objectlib/objects/TwistyBandagedEvil.java
250	250
251	251	///////////////////////////////////////////////////////////////////////////////////////////////////
252	252
253		public int getObjectName(int[] numLayers)
	253	public String getObjectName()
254	254	{
255		return R.string.bandaged_evil;
	255	return "Bandaged Cube B";
256	256	}
257	257
258	258	///////////////////////////////////////////////////////////////////////////////////////////////////
259	259
260		public int getInventor(int[] numLayers)
	260	public String getInventor()
261	261	{
262		return R.string.bandaged_evil_inventor;
	262	return "unknown";
263	263	}
264	264
265	265	///////////////////////////////////////////////////////////////////////////////////////////////////
266	266
267		public int getYearOfInvention(int[] numLayers)
	267	public int getYearOfInvention()
268	268	{
269	269	return 2000;
270	270	}
271	271
272	272	///////////////////////////////////////////////////////////////////////////////////////////////////
273	273
274		public int getComplexity(int[] numLayers)
	274	public int getComplexity()
275	275	{
276	276	return 8;
277	277	}

src/main/java/org/distorted/objectlib/objects/TwistyBandagedFused.java
119	119
120	120	///////////////////////////////////////////////////////////////////////////////////////////////////
121	121
122		public int getObjectName(int[] numLayers)
	122	public String getObjectName()
123	123	{
124		return R.string.bandaged_fused;
	124	return "Fused Cube";
125	125	}
126	126
127	127	///////////////////////////////////////////////////////////////////////////////////////////////////
128	128
129		public int getInventor(int[] numLayers)
	129	public String getInventor()
130	130	{
131		return R.string.bandaged_fused_inventor;
	131	return "unknown";
132	132	}
133	133
134	134	///////////////////////////////////////////////////////////////////////////////////////////////////
135	135
136		public int getYearOfInvention(int[] numLayers)
	136	public int getYearOfInvention()
137	137	{
138	138	return 2000;
139	139	}
140	140
141	141	///////////////////////////////////////////////////////////////////////////////////////////////////
142	142
143		public int getComplexity(int[] numLayers)
	143	public int getComplexity()
144	144	{
145	145	return 8;
146	146	}

src/main/java/org/distorted/objectlib/objects/TwistyCuboid.java
687	687
688	688	///////////////////////////////////////////////////////////////////////////////////////////////////
689	689
690		public int getObjectName(int[] numLayers)
	690	public String getObjectName()
691	691	{
692		switch(numLayers[0])
	692	switch(getNumLayers()[0])
693	693	{
694		case 2: return R.string.cube2;
695		case 3: return R.string.cube3;
696		case 4: return R.string.cube4;
697		case 5: return R.string.cube5;
	694	case 2: return "Pocket Cube";
	695	case 3: return "Rubik Cube";
	696	case 4: return "Rubik's Revenge";
	697	case 5: return "Professor's Cube";
698	698	}
699		return R.string.cube3;
	699	return "Rubik Cube";
700	700	}
701	701
702	702	///////////////////////////////////////////////////////////////////////////////////////////////////
703	703
704		public int getInventor(int[] numLayers)
	704	public String getInventor()
705	705	{
706		switch(numLayers[0])
	706	switch(getNumLayers()[0])
707	707	{
708		case 2: return R.string.cube2_inventor;
709		case 3: return R.string.cube3_inventor;
710		case 4: return R.string.cube4_inventor;
711		case 5: return R.string.cube5_inventor;
	708	case 2: return "Larry Nichols";
	709	case 3: return "Ernő Rubik";
	710	case 4: return "Péter Sebestény";
	711	case 5: return "Udo Krell";
712	712	}
713		return R.string.cube3_inventor;
	713	return "Ernő Rubik";
714	714	}
715	715
716	716	///////////////////////////////////////////////////////////////////////////////////////////////////
717	717
718		public int getYearOfInvention(int[] numLayers)
	718	public int getYearOfInvention()
719	719	{
720		switch(numLayers[0])
	720	switch(getNumLayers()[0])
721	721	{
722	722	case 2: return 1970;
723	723	case 3: return 1974;
...	...
729	729
730	730	///////////////////////////////////////////////////////////////////////////////////////////////////
731	731
732		public int getComplexity(int[] numLayers)
	732	public int getComplexity()
733	733	{
734		switch(numLayers[0])
	734	switch(getNumLayers()[0])
735	735	{
736	736	case 2: return 4;
737	737	case 3: return 6;

     import android.content.res.Resources;
     import org.distorted.library.main.DistortedEffects;
     import org.distorted.library.main.DistortedTexture;
     import org.distorted.library.mesh.MeshSquare;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getObjectName(int[] numLayers)
       public String getObjectName()
+        {
         switch(numLayers[0])
         switch(getNumLayers()[0])
+          {
           case 2: return R.string.diam2;
           case 3: return R.string.diam3;
           case 4: return R.string.diam4;
           case 2: return "Skewb Diamond";
           case 3: return "Face Turning Octahedron";
           case 4: return "Master Face Turning Octahedron";
+          }
         return 0;
         return "Skewb Diamond";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getInventor(int[] numLayers)
       public String getInventor()
+        {
         switch(numLayers[0])
         switch(getNumLayers()[0])
+          {
           case 2: return R.string.diam2_inventor;
           case 3: return R.string.diam3_inventor;
           case 4: return R.string.diam4_inventor;
           case 2: return "Uwe Meffert";
           case 3: return "David Pitcher";
           case 4: return "Timur Evbatyrov";
+          }
         return 0;
         return "Uwe Meffert";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
       public int getYearOfInvention()
+        {
         switch(numLayers[0])
         switch(getNumLayers()[0])
+          {
           case 2: return 1984;
           case 3: return 2003;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)
       public int getComplexity()
+        {
         switch(numLayers[0])
         switch(getNumLayers()[0])
+          {
           case 2: return 4;
           case 3: return 6;

src/main/java/org/distorted/objectlib/objects/TwistyDino.java
283	283
284	284	///////////////////////////////////////////////////////////////////////////////////////////////////
285	285
286		public int getComplexity(int[] numLayers)
	286	public int getComplexity()
287	287	{
288	288	return 2;
289	289	}

src/main/java/org/distorted/objectlib/objects/TwistyDino4.java
24	24	import org.distorted.library.type.Static3D;
25	25	import org.distorted.library.type.Static4D;
26	26
27		import org.distorted.objectlib.R;
28	27	import org.distorted.objectlib.main.ObjectType;
29	28	import org.distorted.objectlib.helpers.ScrambleState;
30	29
...	...
102	101
103	102	///////////////////////////////////////////////////////////////////////////////////////////////////
104	103
105		public int getObjectName(int[] numLayers)
	104	public String getObjectName()
106	105	{
107		return R.string.din43;
	106	return "Dino Cube (4 color)";
108	107	}
109	108
110	109	///////////////////////////////////////////////////////////////////////////////////////////////////
111	110
112		public int getInventor(int[] numLayers)
	111	public String getInventor()
113	112	{
114		return R.string.din43_inventor;
	113	return "Robert Webb";
115	114	}
116	115
117	116	///////////////////////////////////////////////////////////////////////////////////////////////////
118	117
119		public int getYearOfInvention(int[] numLayers)
	118	public int getYearOfInvention()
120	119	{
121	120	return 1985;
122	121	}

src/main/java/org/distorted/objectlib/objects/TwistyDino6.java
24	24	import org.distorted.library.type.Static3D;
25	25	import org.distorted.library.type.Static4D;
26	26
27		import org.distorted.objectlib.R;
28	27	import org.distorted.objectlib.main.ObjectType;
29	28	import org.distorted.objectlib.helpers.ScrambleState;
30	29
...	...
99	98
100	99	///////////////////////////////////////////////////////////////////////////////////////////////////
101	100
102		public int getObjectName(int[] numLayers)
	101	public String getObjectName()
103	102	{
104		return R.string.dino3;
	103	return "Dino Cube (6 color)";
105	104	}
106	105
107	106	///////////////////////////////////////////////////////////////////////////////////////////////////
108	107
109		public int getInventor(int[] numLayers)
	108	public String getInventor()
110	109	{
111		return R.string.dino3_inventor;
	110	return "Robert Webb";
112	111	}
113	112
114	113	///////////////////////////////////////////////////////////////////////////////////////////////////
115	114
116		public int getYearOfInvention(int[] numLayers)
	115	public int getYearOfInvention()
117	116	{
118	117	return 1985;
119	118	}

src/main/java/org/distorted/objectlib/objects/TwistyHelicopter.java
482	482
483	483	///////////////////////////////////////////////////////////////////////////////////////////////////
484	484
485		public int getObjectName(int[] numLayers)
	485	public String getObjectName()
486	486	{
487		return R.string.heli3;
	487	return "Helicopter Cube";
488	488	}
489	489
490	490	///////////////////////////////////////////////////////////////////////////////////////////////////
491	491
492		public int getInventor(int[] numLayers)
	492	public String getInventor()
493	493	{
494		return R.string.heli3_inventor;
	494	return "Adam G. Cowan";
495	495	}
496	496
497	497	///////////////////////////////////////////////////////////////////////////////////////////////////
498	498
499		public int getYearOfInvention(int[] numLayers)
	499	public int getYearOfInvention()
500	500	{
501	501	return 2006;
502	502	}
503	503
504	504	///////////////////////////////////////////////////////////////////////////////////////////////////
505	505
506		public int getComplexity(int[] numLayers)
	506	public int getComplexity()
507	507	{
508	508	return 8;
509	509	}

src/main/java/org/distorted/objectlib/objects/TwistyIvy.java
515	515
516	516	///////////////////////////////////////////////////////////////////////////////////////////////////
517	517
518		public int getObjectName(int[] numLayers)
	518	public String getObjectName()
519	519	{
520		return R.string.ivy2;
	520	return "Ivy Cube";
521	521	}
522	522
523	523	///////////////////////////////////////////////////////////////////////////////////////////////////
524	524
525		public int getInventor(int[] numLayers)
	525	public String getInventor()
526	526	{
527		return R.string.ivy2_inventor;
	527	return "Eitan Cher";
528	528	}
529	529
530	530	///////////////////////////////////////////////////////////////////////////////////////////////////
531	531
532		public int getYearOfInvention(int[] numLayers)
	532	public int getYearOfInvention()
533	533	{
534	534	return 2009;
535	535	}
536	536
537	537	///////////////////////////////////////////////////////////////////////////////////////////////////
538	538
539		public int getComplexity(int[] numLayers)
	539	public int getComplexity()
540	540	{
541	541	return 1;
542	542	}

src/main/java/org/distorted/objectlib/objects/TwistyJing.java
468	468
469	469	///////////////////////////////////////////////////////////////////////////////////////////////////
470	470
471		public int getObjectName(int[] numLayers)
	471	public String getObjectName()
472	472	{
473		return R.string.jing;
	473	return "Jing Pyraminx";
474	474	}
475	475
476	476	///////////////////////////////////////////////////////////////////////////////////////////////////
477	477
478		public int getInventor(int[] numLayers)
	478	public String getInventor()
479	479	{
480		return R.string.jing_inventor;
	480	return "Tony Fisher";
481	481	}
482	482
483	483	///////////////////////////////////////////////////////////////////////////////////////////////////
484	484
485		public int getYearOfInvention(int[] numLayers)
	485	public int getYearOfInvention()
486	486	{
487	487	return 1991;
488	488	}
489	489
490	490	///////////////////////////////////////////////////////////////////////////////////////////////////
491	491
492		public int getComplexity(int[] numLayers)
	492	public int getComplexity()
493	493	{
494	494	return 4;
495	495	}

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getObjectName(int[] numLayers)
       public String getObjectName()
+        {
         int numL = numLayers[0];
         if( numL==3 ) return R.string.minx2;
         if( numL==5 ) return R.string.minx4;
         return 0;
         switch(getNumLayers()[0])
+          {
           case 3: return "Kilominx";
           case 5: return "Master Kilominx";
+          }
         return "Kilominx";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getInventor(int[] numLayers)
       public String getInventor()
+        {
         int numL = numLayers[0];
         if( numL==3 ) return R.string.minx2_inventor;
         if( numL==5 ) return R.string.minx4_inventor;
         return 0;
         switch(getNumLayers()[0])
+          {
           case 3: return "Thomas de Bruin";
           case 5: return "David Gugl";
+          }
         return "Thomas de Bruin";
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getYearOfInvention(int[] numLayers)
       public int getYearOfInvention()
+        {
         switch(numLayers[0])
         switch(getNumLayers()[0])
+          {
           case 3: return 2008;
           case 5: return 2010;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getComplexity(int[] numLayers)
       public int getComplexity()
+        {
         int numL = numLayers[0];
         if( numL==3 ) return 5;
         if( numL==5 ) return 8;
         switch(getNumLayers()[0])
+          {
           case 3: return 5;
           case 5: return 8;
+          }
         return 8;
+        }
+    }

src/main/java/org/distorted/objectlib/objects/TwistyMegaminx.java
627	627	case 3: return ObjectType.MEGA_3;
628	628	case 5: return ObjectType.MEGA_5;
629	629	}
630
631	630	return ObjectType.MEGA_3;
632	631	}
633	632
634	633	///////////////////////////////////////////////////////////////////////////////////////////////////
635	634
636		public int getObjectName(int[] numLayers)
	635	public String getObjectName()
637	636	{
638		int numL = numLayers[0];
639
640		if( numL==3 ) return R.string.minx3;
641		if( numL==5 ) return R.string.minx5;
642
643		return 0;
	637	switch(getNumLayers()[0])
	638	{
	639	case 3: return "Megaminx";
	640	case 5: return "Gigaminx";
	641	}
	642	return "Megaminx";
644	643	}
645	644
646	645	///////////////////////////////////////////////////////////////////////////////////////////////////
647	646
648		public int getInventor(int[] numLayers)
	647	public String getInventor()
649	648	{
650		int numL = numLayers[0];
651
652		if( numL==3 ) return R.string.minx3_inventor;
653		if( numL==5 ) return R.string.minx5_inventor;
654
655		return 0;
	649	switch(getNumLayers()[0])
	650	{
	651	case 3: return "Ferenc Szlivka";
	652	case 5: return "Tyler Fox";
	653	}
	654	return "Ferenc Szlivka";
656	655	}
657	656
658	657	///////////////////////////////////////////////////////////////////////////////////////////////////
659	658
660		public int getYearOfInvention(int[] numLayers)
	659	public int getYearOfInvention()
661	660	{
662		switch(numLayers[0])
	661	switch(getNumLayers()[0])
663	662	{
664	663	case 3: return 1982;
665	664	case 5: return 2006;
666	665	}
667		return 1982;
	666	return 2006;
668	667	}
669	668
670	669	///////////////////////////////////////////////////////////////////////////////////////////////////
671	670
672		public int getComplexity(int[] numLayers)
	671	public int getComplexity()
673	672	{
674		int numL = numLayers[0];
675
676		if( numL==3 ) return 7;
677		if( numL==5 ) return 9;
678
	673	switch(getNumLayers()[0])
	674	{
	675	case 3: return 7;
	676	case 5: return 9;
	677	}
679	678	return 9;
680	679	}
681	680	}

src/main/java/org/distorted/objectlib/objects/TwistyMirror.java
670	670
671	671	///////////////////////////////////////////////////////////////////////////////////////////////////
672	672
673		public int getObjectName(int[] numLayers)
	673	public String getObjectName()
674	674	{
675		switch(numLayers[0])
	675	switch(getNumLayers()[0])
676	676	{
677		case 2: return R.string.mirr2;
678		case 3: return R.string.mirr3;
	677	case 2: return "Pocket Mirror";
	678	case 3: return "Mirror Cube";
679	679	}
680		return R.string.mirr3;
	680	return "Pocket Mirror";
681	681	}
682	682
683	683	///////////////////////////////////////////////////////////////////////////////////////////////////
684	684
685		public int getInventor(int[] numLayers)
	685	public String getInventor()
686	686	{
687		switch(numLayers[0])
	687	switch(getNumLayers()[0])
688	688	{
689		case 2: return R.string.mirr2_inventor;
690		case 3: return R.string.mirr3_inventor;
	689	case 2: return "Thomas de Bruin";
	690	case 3: return "Hidetoshi Takeji";
691	691	}
692		return R.string.mirr3_inventor;
	692	return "Hidetoshi Takeji";
693	693	}
694	694
695	695	///////////////////////////////////////////////////////////////////////////////////////////////////
696	696
697		public int getYearOfInvention(int[] numLayers)
	697	public int getYearOfInvention()
698	698	{
699		switch(numLayers[0])
	699	switch(getNumLayers()[0])
700	700	{
701	701	case 2: return 2007;
702	702	case 3: return 2006;
...	...
706	706
707	707	///////////////////////////////////////////////////////////////////////////////////////////////////
708	708
709		public int getComplexity(int[] numLayers)
	709	public int getComplexity()
710	710	{
711		switch(numLayers[0])
	711	switch(getNumLayers()[0])
712	712	{
713	713	case 2: return 5;
714	714	case 3: return 7;

src/main/java/org/distorted/objectlib/objects/TwistyPyraminx.java
466	466
467	467	///////////////////////////////////////////////////////////////////////////////////////////////////
468	468
469		public int getObjectName(int[] numLayers)
	469	public String getObjectName()
470	470	{
471		switch(numLayers[0])
	471	switch(getNumLayers()[0])
472	472	{
473		case 3: return R.string.pyra3;
474		case 4: return R.string.pyra4;
475		case 5: return R.string.pyra5;
	473	case 3: return "Pyraminx";
	474	case 4: return "Master Pyraminx";
	475	case 5: return "Professor's Pyraminx";
476	476	}
477		return R.string.pyra3;
	477	return "Pyraminx";
478	478	}
479	479
480	480	///////////////////////////////////////////////////////////////////////////////////////////////////
481	481
482		public int getInventor(int[] numLayers)
	482	public String getInventor()
483	483	{
484		switch(numLayers[0])
	484	switch(getNumLayers()[0])
485	485	{
486		case 3: return R.string.pyra3_inventor;
487		case 4: return R.string.pyra4_inventor;
488		case 5: return R.string.pyra5_inventor;
	486	case 3: return "Uwe Meffert";
	487	case 4: return "Katsuhiko Okamoto";
	488	case 5: return "Timur Evbatyrov";
489	489	}
490		return R.string.pyra3_inventor;
	490	return "Uwe Meffert";
491	491	}
492	492
493	493	///////////////////////////////////////////////////////////////////////////////////////////////////
494	494
495		public int getYearOfInvention(int[] numLayers)
	495	public int getYearOfInvention()
496	496	{
497		switch(numLayers[0])
	497	switch(getNumLayers()[0])
498	498	{
499	499	case 3: return 1970;
500	500	case 4: return 2002;
...	...
505	505
506	506	///////////////////////////////////////////////////////////////////////////////////////////////////
507	507
508		public int getComplexity(int[] numLayers)
	508	public int getComplexity()
509	509	{
510		switch(numLayers[0])
	510	switch(getNumLayers()[0])
511	511	{
512	512	case 3: return 4;
513	513	case 4: return 6;

src/main/java/org/distorted/objectlib/objects/TwistyRedi.java
477	477
478	478	///////////////////////////////////////////////////////////////////////////////////////////////////
479	479
480		public int getObjectName(int[] numLayers)
	480	public String getObjectName()
481	481	{
482		return R.string.redi2;
	482	return "Redi Cube";
483	483	}
484	484
485	485	///////////////////////////////////////////////////////////////////////////////////////////////////
486	486
487		public int getInventor(int[] numLayers)
	487	public String getInventor()
488	488	{
489		return R.string.redi2_inventor;
	489	return "Oskar van Deventer";
490	490	}
491	491
492	492	///////////////////////////////////////////////////////////////////////////////////////////////////
493	493
494		public int getYearOfInvention(int[] numLayers)
	494	public int getYearOfInvention()
495	495	{
496	496	return 2009;
497	497	}
498	498
499	499	///////////////////////////////////////////////////////////////////////////////////////////////////
500	500
501		public int getComplexity(int[] numLayers)
	501	public int getComplexity()
502	502	{
503	503	return 4;
504	504	}

src/main/java/org/distorted/objectlib/objects/TwistyRex.java
514	514
515	515	///////////////////////////////////////////////////////////////////////////////////////////////////
516	516
517		public int getObjectName(int[] numLayers)
	517	public String getObjectName()
518	518	{
519		return R.string.rex3;
	519	return "Rex Cube";
520	520	}
521	521
522	522	///////////////////////////////////////////////////////////////////////////////////////////////////
523	523
524		public int getInventor(int[] numLayers)
	524	public String getInventor()
525	525	{
526		return R.string.rex3_inventor;
	526	return "Andrew Cormier";
527	527	}
528	528
529	529	///////////////////////////////////////////////////////////////////////////////////////////////////
530	530
531		public int getYearOfInvention(int[] numLayers)
	531	public int getYearOfInvention()
532	532	{
533	533	return 2009;
534	534	}
535	535
536	536	///////////////////////////////////////////////////////////////////////////////////////////////////
537	537
538		public int getComplexity(int[] numLayers)
	538	public int getComplexity()
539	539	{
540	540	return 3;
541	541	}

src/main/java/org/distorted/objectlib/objects/TwistySkewb.java
638	638
639	639	///////////////////////////////////////////////////////////////////////////////////////////////////
640	640
641		public int getObjectName(int[] numLayers)
	641	public String getObjectName()
642	642	{
643		switch(numLayers[0])
	643	switch(getNumLayers()[0])
644	644	{
645		case 2: return R.string.skew2;
646		case 3: return R.string.skew3;
	645	case 2: return "Skewb";
	646	case 3: return "Master Skewb";
647	647	}
648		return R.string.skew2;
	648	return "Skewb";
649	649	}
650	650
651	651	///////////////////////////////////////////////////////////////////////////////////////////////////
652	652
653		public int getInventor(int[] numLayers)
	653	public String getInventor()
654	654	{
655		switch(numLayers[0])
	655	switch(getNumLayers()[0])
656	656	{
657		case 2: return R.string.skew2_inventor;
658		case 3: return R.string.skew3_inventor;
	657	case 2: return "Tony Durham";
	658	case 3: return "Katsuhiko Okamoto";
659	659	}
660		return R.string.skew2_inventor;
	660	return "Tony Durham";
661	661	}
662	662
663	663	///////////////////////////////////////////////////////////////////////////////////////////////////
664	664
665		public int getYearOfInvention(int[] numLayers)
	665	public int getYearOfInvention()
666	666	{
667		switch(numLayers[0])
	667	switch(getNumLayers()[0])
668	668	{
669	669	case 2: return 1982;
670	670	case 3: return 2003;
...	...
674	674
675	675	///////////////////////////////////////////////////////////////////////////////////////////////////
676	676
677		public int getComplexity(int[] numLayers)
	677	public int getComplexity()
678	678	{
679		switch(numLayers[0])
	679	switch(getNumLayers()[0])
680	680	{
681	681	case 2: return 4;
682	682	case 3: return 8;

src/main/java/org/distorted/objectlib/objects/TwistySquare1.java
370	370
371	371	///////////////////////////////////////////////////////////////////////////////////////////////////

Project

General

Profile

TwistyPuzzleLib

Revision e26eb4e7

Added by Leszek Koltunski over 2 years ago