commit 0203be88e43da8b7cb5c4999d643c00fd2c0d9b1
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Thu Jun 3 22:06:59 2021 +0200

    Remove the need for RowChances.

diff --git a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java b/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java
index d4a048cf..399caf84 100644
--- a/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java
+++ b/src/main/java/org/distorted/objects/TwistyBandagedAbstract.java
@@ -535,20 +535,6 @@ abstract class TwistyBandagedAbstract extends TwistyObject
     return getNumLayers();
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    float[] chances = new float[numLayers];
-
-    for(int i=0; i<numLayers; i++)
-      {
-      chances[i] = (i+1.0f) / numLayers;
-      }
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
diff --git a/src/main/java/org/distorted/objects/TwistyBandagedEvil.java b/src/main/java/org/distorted/objects/TwistyBandagedEvil.java
index 15297e3e..5992af26 100644
--- a/src/main/java/org/distorted/objects/TwistyBandagedEvil.java
+++ b/src/main/java/org/distorted/objects/TwistyBandagedEvil.java
@@ -263,8 +263,6 @@ class TwistyBandagedEvil extends TwistyBandagedAbstract
       case 1: mUseX = true ; mUseY = false; mUseZ = true ; break;
       case 2: mUseX = true ; mUseY = true ; mUseZ = false; break;
       }
-
-    //android.util.Log.e("D", (info[0]==0 ? "X" : (info[0]==1 ? "Y" : "Z")) + info[2] +" --> "+info[3]);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/objects/TwistyBandagedFused.java b/src/main/java/org/distorted/objects/TwistyBandagedFused.java
index e034662e..5be927d5 100644
--- a/src/main/java/org/distorted/objects/TwistyBandagedFused.java
+++ b/src/main/java/org/distorted/objects/TwistyBandagedFused.java
@@ -103,10 +103,11 @@ class TwistyBandagedFused extends TwistyBandagedAbstract
       }
 
     float rowFloat = rnd.nextFloat();
+    int numLayers = getNumLayers();
 
-    for(int row=0; row<mRowChances.length; row++)
+    for(int row=0; row<numLayers; row++)
       {
-      if( rowFloat<=mRowChances[row] )
+      if( rowFloat*numLayers <= row+1 )
         {
         scramble[num][1] = row;
         break;
diff --git a/src/main/java/org/distorted/objects/TwistyCube.java b/src/main/java/org/distorted/objects/TwistyCube.java
index 0646a37f..b5894624 100644
--- a/src/main/java/org/distorted/objects/TwistyCube.java
+++ b/src/main/java/org/distorted/objects/TwistyCube.java
@@ -277,20 +277,6 @@ class TwistyCube extends TwistyObject
     return getNumLayers();
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    float[] chances = new float[numLayers];
-
-    for(int i=0; i<numLayers; i++)
-      {
-      chances[i] = (i+1.0f) / numLayers;
-      }
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
@@ -321,10 +307,11 @@ class TwistyCube extends TwistyObject
       }
 
     float rowFloat = rnd.nextFloat();
+    int numLayers = getNumLayers();
 
-    for(int row=0; row<mRowChances.length; row++)
+    for(int row=0; row<numLayers; row++)
       {
-      if( rowFloat<=mRowChances[row] )
+      if( rowFloat*numLayers <= row+1 )
         {
         scramble[num][1] = row;
         break;
diff --git a/src/main/java/org/distorted/objects/TwistyDiamond.java b/src/main/java/org/distorted/objects/TwistyDiamond.java
index f29b1997..328b57b8 100644
--- a/src/main/java/org/distorted/objects/TwistyDiamond.java
+++ b/src/main/java/org/distorted/objects/TwistyDiamond.java
@@ -500,17 +500,6 @@ public class TwistyDiamond extends TwistyObject
     return 1.5f;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    float[] chances = new float[numLayers];
-
-    for(int i=0; i<numLayers; i++) chances[i] = ((float)(i+1))/numLayers;
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
@@ -541,10 +530,11 @@ public class TwistyDiamond extends TwistyObject
       }
 
     float rowFloat = rnd.nextFloat();
+    int numLayers = getNumLayers();
 
-    for(int row=0; row<mRowChances.length; row++)
+    for(int row=0; row<numLayers; row++)
       {
-      if( rowFloat<=mRowChances[row] )
+      if( rowFloat*numLayers <= row+1 )
         {
         scramble[num][1] = row;
         break;
diff --git a/src/main/java/org/distorted/objects/TwistyDino.java b/src/main/java/org/distorted/objects/TwistyDino.java
index eb64f545..7f10661a 100644
--- a/src/main/java/org/distorted/objects/TwistyDino.java
+++ b/src/main/java/org/distorted/objects/TwistyDino.java
@@ -226,19 +226,6 @@ public abstract class TwistyDino extends TwistyObject
     return 2.0f;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    float[] chances = new float[3];
-
-    chances[0] = 0.5f;
-    chances[1] = 0.5f;
-    chances[2] = 1.0f;
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
diff --git a/src/main/java/org/distorted/objects/TwistyHelicopter.java b/src/main/java/org/distorted/objects/TwistyHelicopter.java
index eb5baf69..f0ace352 100644
--- a/src/main/java/org/distorted/objects/TwistyHelicopter.java
+++ b/src/main/java/org/distorted/objects/TwistyHelicopter.java
@@ -393,19 +393,6 @@ public class TwistyHelicopter extends TwistyObject
     return 2.0f;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    float[] chances = new float[3];
-
-    chances[0] = 0.5f;
-    chances[1] = 0.5f;
-    chances[2] = 1.0f;
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
@@ -446,16 +433,7 @@ public class TwistyHelicopter extends TwistyObject
         }
       }
 
-    float rowFloat = rnd.nextFloat();
-
-    for(int row=0; row<mRowChances.length; row++)
-      {
-      if( rowFloat<=mRowChances[row] )
-        {
-        scramble[num][1] = row;
-        break;
-        }
-      }
+    scramble[num][1] = rnd.nextFloat()<=0.5f ? 0 : 2;
 
     switch( rnd.nextInt(2) )
       {
diff --git a/src/main/java/org/distorted/objects/TwistyIvy.java b/src/main/java/org/distorted/objects/TwistyIvy.java
index 7c978d33..60b01359 100644
--- a/src/main/java/org/distorted/objects/TwistyIvy.java
+++ b/src/main/java/org/distorted/objects/TwistyIvy.java
@@ -416,17 +416,6 @@ public class TwistyIvy extends TwistyObject
     return 2.0f;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    float[] chances = new float[2];
-    chances[0] = 0.5f;
-    chances[1] = 1.0f;
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
@@ -456,16 +445,7 @@ public class TwistyIvy extends TwistyObject
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
-    float rowFloat = rnd.nextFloat();
-
-    for(int row=0; row<mRowChances.length; row++)
-      {
-      if( rowFloat<=mRowChances[row] )
-        {
-        scramble[num][1] = row;
-        break;
-        }
-      }
+    scramble[num][1] = rnd.nextFloat()<=0.5f ? 0 : 1;
 
     switch( rnd.nextInt(2) )
       {
diff --git a/src/main/java/org/distorted/objects/TwistyMinx.java b/src/main/java/org/distorted/objects/TwistyMinx.java
index 99d7143e..fbbf8bf2 100644
--- a/src/main/java/org/distorted/objects/TwistyMinx.java
+++ b/src/main/java/org/distorted/objects/TwistyMinx.java
@@ -324,6 +324,7 @@ abstract class TwistyMinx extends TwistyObject
     mBasicCornerV[2] = new Static4D(              0,        -0.500f,    0.0f, 0.0f );
     }
 
+  private static float[] mRowChances;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -333,6 +334,20 @@ abstract class TwistyMinx extends TwistyObject
     super(numLayers, realSize, quat, texture, mesh, effects, moves, obj, res, scrWidth);
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private float[] getRowChances(int numLayers)
+    {
+    float[] chances = new float[numLayers];
+    float denom = (float)(numLayers-1);
+    int change  = (numLayers-1)/2;
+
+    for(int i=     0; i<change   ; i++) chances[i] = (i+1)/denom;
+    for(int i=change; i<numLayers; i++) chances[i] = (i  )/denom;
+
+    return chances;
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   Static4D[] getQuats()
@@ -368,20 +383,6 @@ abstract class TwistyMinx extends TwistyObject
     return 2.0f;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    float[] chances = new float[numLayers];
-    float denom = (float)(numLayers-1);
-    int change  = (numLayers-1)/2;
-
-    for(int i=     0; i<change   ; i++) chances[i] = (i+1)/denom;
-    for(int i=change; i<numLayers; i++) chances[i] = (i  )/denom;
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   MeshBase createCornerMesh(int numLayers, float width)
@@ -458,6 +459,10 @@ abstract class TwistyMinx extends TwistyObject
 
   public void randomizeNewScramble(int[][] scramble, Random rnd, int num)
     {
+    int numLayers = getNumLayers();
+
+    if( mRowChances==null ) mRowChances = getRowChances(numLayers);
+
     if( num==0 )
       {
       scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
@@ -472,7 +477,7 @@ abstract class TwistyMinx extends TwistyObject
       {
       float rowFloat = rnd.nextFloat();
 
-      for(int row=0; row<mRowChances.length; row++)
+      for(int row=0; row<numLayers; row++)
         {
         if( rowFloat<=mRowChances[row] )
           {
@@ -483,12 +488,11 @@ abstract class TwistyMinx extends TwistyObject
       }
     else
       {
-      int size = mRowChances.length;
-      int nom = (size-1)/2;
+      int nom = (numLayers-1)/2;
       int row = rnd.nextInt(nom);
       boolean opposite = OPPOSITE_ROWS[scramble[num-1][0]][scramble[num][0]];
       boolean low = opposite^(scramble[num-1][1]<nom);
-      scramble[num][1] = low ? row : size-1-row;
+      scramble[num][1] = low ? row : numLayers-1-row;
       }
 
     switch( rnd.nextInt(4) )
diff --git a/src/main/java/org/distorted/objects/TwistyObject.java b/src/main/java/org/distorted/objects/TwistyObject.java
index b24a166b..5a75e2ff 100644
--- a/src/main/java/org/distorted/objects/TwistyObject.java
+++ b/src/main/java/org/distorted/objects/TwistyObject.java
@@ -118,7 +118,6 @@ public abstract class TwistyObject extends DistortedNode
   private int mRotAxis;
   private MeshBase mMesh;
 
-  float[] mRowChances;
   Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;
   DistortedTexture mTexture;
   MatrixEffectScale mScaleEffect;
@@ -159,8 +158,6 @@ public abstract class TwistyObject extends DistortedNode
     mNodeScale= new Static3D(1,NODE_RATIO,1);
     mQuat = quat;
 
-    mRowChances = getRowChances(mNumLayers);
-
     mRotationAngle= new Dynamic1D();
     mRotationAxis = new Static3D(1,0,0);
     mRotateEffect = new VertexEffectRotate(mRotationAngle, mRotationAxis, CENTER);
@@ -965,7 +962,6 @@ public abstract class TwistyObject extends DistortedNode
   abstract void createFaceTexture(Canvas canvas, Paint paint, int face, int left, int top);
   abstract int getFaceColor(int cubit, int cubitface, int numLayers);
   abstract float returnMultiplier();
-  abstract float[] getRowChances(int numLayers);
   abstract float[] getCuts(int numLayers);
   abstract boolean shouldResetTextureMaps();
 
diff --git a/src/main/java/org/distorted/objects/TwistyPyraminx.java b/src/main/java/org/distorted/objects/TwistyPyraminx.java
index faadcf6f..ef21d14e 100644
--- a/src/main/java/org/distorted/objects/TwistyPyraminx.java
+++ b/src/main/java/org/distorted/objects/TwistyPyraminx.java
@@ -114,6 +114,7 @@ public class TwistyPyraminx extends TwistyObject
           };
 
   private static MeshBase[] mMeshes;
+  private static float[] mRowChances;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -123,6 +124,23 @@ public class TwistyPyraminx extends TwistyObject
     super(size, size, quat, texture, mesh, effects, moves, ObjectList.PYRA, res, scrWidth);
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private float[] getRowChances(int numLayers)
+    {
+    int total = numLayers*(numLayers+1)/2;
+    float running=0.0f;
+    float[] chances = new float[numLayers];
+
+    for(int i=0; i<numLayers; i++)
+      {
+      running += (numLayers-i);
+      chances[i] = running / total;
+      }
+
+    return chances;
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   private void addTetrahedralLattice(int size, int index, float[][] pos)
@@ -349,23 +367,6 @@ public class TwistyPyraminx extends TwistyObject
     return getNumLayers()/(SQ6/3);
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    int total = numLayers*(numLayers+1)/2;
-    float running=0.0f;
-    float[] chances = new float[numLayers];
-
-    for(int i=0; i<numLayers; i++)
-      {
-      running += (numLayers-i);
-      chances[i] = running / total;
-      }
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
@@ -385,6 +386,10 @@ public class TwistyPyraminx extends TwistyObject
 
   public void randomizeNewScramble(int[][] scramble, Random rnd, int num)
     {
+    int numLayers = getNumLayers();
+
+    if( mRowChances==null ) mRowChances = getRowChances(numLayers);
+
     if( num==0 )
       {
       scramble[num][0] = rnd.nextInt(ROTATION_AXIS.length);
@@ -397,7 +402,7 @@ public class TwistyPyraminx extends TwistyObject
 
     float rowFloat = rnd.nextFloat();
 
-    for(int row=0; row<mRowChances.length; row++)
+    for(int row=0; row<numLayers; row++)
       {
       if( rowFloat<=mRowChances[row] )
         {
diff --git a/src/main/java/org/distorted/objects/TwistyRedi.java b/src/main/java/org/distorted/objects/TwistyRedi.java
index b6e07221..02dab9a9 100644
--- a/src/main/java/org/distorted/objects/TwistyRedi.java
+++ b/src/main/java/org/distorted/objects/TwistyRedi.java
@@ -406,19 +406,6 @@ public class TwistyRedi extends TwistyObject
     return 2.0f;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    float[] chances = new float[3];
-
-    chances[0] = 0.5f;
-    chances[1] = 0.5f;
-    chances[2] = 1.0f;
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
diff --git a/src/main/java/org/distorted/objects/TwistyRex.java b/src/main/java/org/distorted/objects/TwistyRex.java
index af03ceda..935fe371 100644
--- a/src/main/java/org/distorted/objects/TwistyRex.java
+++ b/src/main/java/org/distorted/objects/TwistyRex.java
@@ -581,13 +581,6 @@ public class TwistyRex extends TwistyObject
     return 2.0f;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    return new float[] { 0.5f, 0.5f, 1.0f };
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
@@ -617,16 +610,7 @@ public class TwistyRex extends TwistyObject
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
-    float rowFloat = rnd.nextFloat();
-
-    for(int row=0; row<mRowChances.length; row++)
-      {
-      if( rowFloat<=mRowChances[row] )
-        {
-        scramble[num][1] = row;
-        break;
-        }
-      }
+    scramble[num][1] = rnd.nextFloat()<=0.5f ? 0 : 2;
 
     switch( rnd.nextInt(2) )
       {
diff --git a/src/main/java/org/distorted/objects/TwistySkewb.java b/src/main/java/org/distorted/objects/TwistySkewb.java
index cbd862ad..a9a49db1 100644
--- a/src/main/java/org/distorted/objects/TwistySkewb.java
+++ b/src/main/java/org/distorted/objects/TwistySkewb.java
@@ -601,30 +601,6 @@ public class TwistySkewb extends TwistyObject
     return 2.0f;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    float[] chances = new float[numLayers];
-
-    switch(numLayers)
-      {
-      case 2: chances[0] = 0.5f;
-              chances[1] = 1.0f;
-              break;
-      case 3: chances[0] = 0.5f;
-              chances[1] = 0.5f;
-              chances[2] = 1.0f;
-              break;
-      default:for(int i=0; i<numLayers; i++)
-                {
-                chances[i] = (float)(i+1)/numLayers;
-                }
-      }
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
@@ -654,16 +630,7 @@ public class TwistySkewb extends TwistyObject
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
-    float rowFloat = rnd.nextFloat();
-
-    for(int row=0; row<mRowChances.length; row++)
-      {
-      if( rowFloat<=mRowChances[row] )
-        {
-        scramble[num][1] = row;
-        break;
-        }
-      }
+    scramble[num][1] = rnd.nextFloat()<=0.5f ? 0 : getNumLayers()-1;
 
     switch( rnd.nextInt(2) )
       {
diff --git a/src/main/java/org/distorted/objects/TwistySquare1.java b/src/main/java/org/distorted/objects/TwistySquare1.java
index 9c341f40..e18cc25c 100644
--- a/src/main/java/org/distorted/objects/TwistySquare1.java
+++ b/src/main/java/org/distorted/objects/TwistySquare1.java
@@ -200,7 +200,7 @@ class TwistySquare1 extends TwistyObject
            {       5,NUM_ST,2,     2,NUM_ST,NUM_ST }
          };
 
-  // YELLOW 0 WHITE 1 BLUE 2 GREEN 3 RED 4  ORANGE 5
+  // YELLOW 0 WHITE 1 BLUE 2 GREEN 3 RED 4 ORANGE 5
   private static final int[][] mStickerColor = new int[][]
          {
            { 0, 0, 4, 0, 5, 0 },
@@ -350,7 +350,7 @@ class TwistySquare1 extends TwistyObject
       {
       case 0:  R = 0.06f; S = 0.05f; break;
       case 1:  R = 0.04f; S = 0.04f; break;
-      case 2:  R = 0.10f; S = 0.08f; break;
+      case 2:  R = 0.11f; S = 0.09f; break;
       case 3:  R = 0.03f; S = 0.05f; break;
       case 4:  R = 0.11f; S = 0.08f; break;
       case 5:  R = 0.08f; S = 0.08f; break;
@@ -445,21 +445,6 @@ class TwistySquare1 extends TwistyObject
     return 1.0f;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// TODO
-
-  float[] getRowChances(int numLayers)
-    {
-    float[] chances = new float[numLayers];
-
-    for(int i=0; i<numLayers; i++)
-      {
-      chances[i] = (i+1.0f) / numLayers;
-      }
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
@@ -491,16 +476,7 @@ class TwistySquare1 extends TwistyObject
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
-    float rowFloat = rnd.nextFloat();
-
-    for(int row=0; row<mRowChances.length; row++)
-      {
-      if( rowFloat<=mRowChances[row] )
-        {
-        scramble[num][1] = row;
-        break;
-        }
-      }
+    scramble[num][1] = rnd.nextFloat()<=0.5f ? 0 : 1;
 
     switch( rnd.nextInt(4) )
       {
diff --git a/src/main/java/org/distorted/objects/TwistyUltimate.java b/src/main/java/org/distorted/objects/TwistyUltimate.java
index 6a4fafb3..c8fc6079 100644
--- a/src/main/java/org/distorted/objects/TwistyUltimate.java
+++ b/src/main/java/org/distorted/objects/TwistyUltimate.java
@@ -424,17 +424,6 @@ class TwistyUltimate extends TwistyObject
     return 0.67f;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[] getRowChances(int numLayers)
-    {
-    float[] chances = new float[2];
-    chances[0] = 0.5f;
-    chances[1] = 1.0f;
-
-    return chances;
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PUBLIC API
 
@@ -464,16 +453,7 @@ class TwistyUltimate extends TwistyObject
       scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
       }
 
-    float rowFloat = rnd.nextFloat();
-
-    for(int row=0; row<mRowChances.length; row++)
-      {
-      if( rowFloat<=mRowChances[row] )
-        {
-        scramble[num][1] = row;
-        break;
-        }
-      }
+    scramble[num][1] = rnd.nextFloat()<=0.5f ? 0 : 1;
 
     switch( rnd.nextInt(2) )
       {