RandomEssentials.cs

Go to the documentation of this file.

using System;
 
namespace UnityEngine
{
    public class RandomEssentials : System.Random
    {
 
        #region Constructors
        
        public RandomEssentials()
        {
        }
 
        public RandomEssentials(int seed) : base(seed)
        {
        }
        
        public static RandomEssentials GetNew()
        {
            return new RandomEssentials();
        }
        
        public static RandomEssentials GetNew(int seed)
        {
            return new RandomEssentials(seed);
        }
        
        #endregion
 
        #region Int
 
        public int GetRandomInt()
        {
            return Next();
        }
 
        public int GetRandomInt(int exclusiveMaximum)
        {
            return Next(exclusiveMaximum);
        }
 
        public int GetRandomInt(int inclusiveMinimum, int exclusiveMaximum)
        {
            return Next(inclusiveMinimum, exclusiveMaximum);
        }
 
        #endregion
 
        #region Sign
 
        public int GetRandomSign(float negativeProbability = 0.5f)
        {
            return GetRandomBool(negativeProbability) ? -1 : 1;
        }
 
        #endregion
 
        #region Bool
 
        public bool GetRandomBool(float probability = 0.5f)
        {
            return NextDouble() >= 1 - probability;
        }
 
        public bool GetRandomBoolTrueEnsured(int tryNumberSinceLastPositive, int maxNumberOfTries)
        {
            return GetRandomBool((float) tryNumberSinceLastPositive / (float) maxNumberOfTries);
        }
 
        public bool GetPseudoRandomDistributedBool(int tryNumberSinceLastPositive, float probability)
        {
            return GetRandomBool(Mathf.Pow(probability, 1.72689f) * tryNumberSinceLastPositive);
 
            // An image of how the results should distribute (in blue): https://gamepedia.cursecdn.com/dota2_gamepedia/8/8b/AttacksUntilNextProc25.jpg?version=459537150af02c929fd939495fa78033
 
            /* The true formula to calculate each try's probability is: "C * tryNumber"
            // In this method's implementation, "C" is calculated using the formula: "probability^1.72689"
            // However, the accuracy of the results could be improved by using this table instead of the previous calculus:
                Probability    Associated "C"                              
                5%             0.003801658303553139101756466
                10%            0.014745844781072675877050816
                15%            0.032220914373087674975117359
                20%            0.055704042949781851858398652
                25%            0.084744091852316990275274806
                30%            0.118949192725403987583755553
                35%            0.157983098125747077557540462
                40%            0.201547413607754017070679639
                45%            0.249306998440163189714677100
                50%            0.302103025348741965169160432
                55%            0.360397850933168697104686803
                60%            0.422649730810374235490851220
                65%            0.481125478337229174401911323
                70%            0.571428571428571428571428572
                75%            0.666666666666666666666666667
                80%            0.750000000000000000000000000
                85%            0.823529411764705882352941177
                90%            0.888888888888888888888888889
                95%            0.947368421052631578947368421
             */
        }
 
        #endregion
 
        #region Float
 
        public float GetRandomFloat()
        {
            return Convert.ToSingle(NextDouble());
        }
 
        public float GetRandomFloat(float exclusiveMaximum)
        {
            return Convert.ToSingle(NextDouble() * exclusiveMaximum);
        }
 
        public float GetRandomFloat(float inclusiveMinimum, float exclusiveMaximum)
        {
            return Convert.ToSingle(NextDouble() * (exclusiveMaximum - inclusiveMinimum)) + inclusiveMinimum;
        }
 
        #endregion
 
        #region Vectors
 
        public Vector3 GetRandomVector3(float inclusiveMinimum, float exclusiveMaximum)
        {
            return new Vector3(GetRandomFloat(inclusiveMinimum, exclusiveMaximum), GetRandomFloat(inclusiveMinimum, exclusiveMaximum), GetRandomFloat(inclusiveMinimum, exclusiveMaximum));
        }
 
        public Vector2 GetRandomVector2(float inclusiveMinimum, float exclusiveMaximum)
        {
            return new Vector2(GetRandomFloat(inclusiveMinimum, exclusiveMaximum), GetRandomFloat(inclusiveMinimum, exclusiveMaximum));
        }
 
        #endregion
 
        #region Bytes
 
        public void SetRandomBytes(Byte[] bytesArray)
        {
            NextBytes(bytesArray);
        }
        
        #endregion
 
        #region Geometry
        
        public Vector2 GetPointInsideCircle(Vector2 center, float radius = 1f)
        {
            double angle = this.NextDouble() * 2 * Math.PI;
            double r = radius * Math.Sqrt(NextDouble());
            double x = center.x + r * Math.Cos(angle);
            double y = center.y + r * Math.Sin(angle);
            return new Vector2( Convert.ToSingle(x), Convert.ToSingle(y) );
        }   
        
        public Vector2 GetPointInsideCircle( float radius = 1f)
        {
            return GetPointInsideCircle(Vector2.zero, radius);
        }   
        
        
        public Vector2 GetPointOnCircle(Vector2 center, float radius = 1f)
        {
            double angle = 2.0 * Math.PI * this.NextDouble();
            double x = center.x + radius * Math.Cos(angle);
            double y = center.y + radius * Math.Sin(angle);
            return new Vector2( Convert.ToSingle(x), Convert.ToSingle(y) );
        }   
        
        public Vector2 GetPointOnCircle( float radius = 1f)
        {
            return GetPointInsideCircle(Vector2.zero, radius);
        }   
        
        // Similar methods to the ones Unity's Random class has
        //To-do: public Vector3 GetPointInsideSphere(float radius = 1){}    //Returns a random point inside a sphere
        //To-do: public Vector3 GetPointOnSphere(float radius = 1){}    //Returns a random point on the surface of a sphere
        
        // Similar methods to the ones Unity's Random class has
        //To-do: public Quaternion GetRotation(){}  //Returns a random rotation
        //To-do: public Quaternion GetRotationUniform(){}   //Returns a random rotation with uniform distribution
 
        #endregion
 
        #region Color
 
        public Color GetColorHSV(float hueMin = 0.0f, float hueMax = 1f, float saturationMin = 0.0f, float saturationMax = 1f, float valueMin = 0.0f, float valueMax = 1f, float alphaMin = 1f, float alphaMax = 1f)
        {
            Color rgb = Color.HSVToRGB(Mathf.Lerp(hueMin, hueMax, GetRandomFloat()), Mathf.Lerp(saturationMin, saturationMax, GetRandomFloat()), Mathf.Lerp(valueMin, valueMax, GetRandomFloat()), true);
            rgb.a = Mathf.Lerp(alphaMin, alphaMax, GetRandomFloat());
            return rgb;
        }
        
        #endregion
 
 
    }
}