MinMaxCurve beyond particles

[SerializeField] Vector2 scaleRange = new Vector2(0.5f, 2f);

float scale = Random.Range(scaleRange.x, scaleRange.y);

It works until the design changes. "Trees next to the road should be smaller." Now you need a second range, a distance check and a blend between them. "Make it a smooth falloff instead." Now you add an AnimationCurve. Every design change becomes a code change.

[SerializeField] ParticleSystem.MinMaxCurve scale = new ParticleSystem.MinMaxCurve(1f);

// x: your input, normalized to 0..1.   r: your random value, 0..1.
float s = scale.Evaluate(x, r);

Two Curves is the one people skip, and it's the one that replaces most of the extra code. Here is what it computes:

Each enemy rolls r once and keeps it. Drag the level slider: the strongest enemy stays the strongest at every level. If you re-rolled r on level-up, your elite could become the weakest one in the wave.

The same rule applies in your own code: if you evaluate a MinMaxCurve more than once for the same object, keep that object's r.

using UnityEngine;
using MinMaxCurve = UnityEngine.ParticleSystem.MinMaxCurve;

public class RoadsideScatter : MonoBehaviour
{
    [SerializeField] float maxDistance = 20f;
    [SerializeField] int seed = 1234;

    // Keys stay in 0..1. curveMultiplier (2.2) is the largest scale.
    [SerializeField] MinMaxCurve scaleByDistance = new MinMaxCurve(
        2.2f,
        new AnimationCurve(new Keyframe(0f, 0.13f), new Keyframe(0.5f, 0.19f), new Keyframe(1f, 0.25f)),
        new AnimationCurve(new Keyframe(0f, 0.22f), new Keyframe(0.45f, 0.66f), new Keyframe(1f, 1f)));

    System.Random rng;

    void Awake() => rng = new System.Random(seed); // same seed, same forest

    public float PickScale(float distanceToRoad)
    {
        float x = Mathf.Clamp01(distanceToRoad / maxDistance); // input: not random
        float r = (float)rng.NextDouble();                      // the only random value
        return scaleByDistance.Evaluate(x, r);
    }
}

using UnityEngine;
using MinMaxCurve = UnityEngine.ParticleSystem.MinMaxCurve;

public class EnemyStats : MonoBehaviour
{
    [SerializeField] int maxLevel = 20;

    // Keys stay in 0..1. curveMultiplier (600) is the highest possible health.
    [SerializeField] MinMaxCurve healthByLevel = new MinMaxCurve(
        600f,
        new AnimationCurve(new Keyframe(0f, 0.133f), new Keyframe(0.5f, 0.283f), new Keyframe(1f, 0.5f)),
        new AnimationCurve(new Keyframe(0f, 0.167f), new Keyframe(0.5f, 0.55f), new Keyframe(1f, 1f)));

    float healthRoll; // this enemy's r: rolled once, kept for its whole life

    public void Init(System.Random rng) => healthRoll = (float)rng.NextDouble();

    public int MaxHealthAt(int level)
    {
        float x = Mathf.InverseLerp(1, maxLevel, level); // input: not random
        return Mathf.RoundToInt(healthByLevel.Evaluate(x, healthRoll));
    }
}

The same idea for colors

ParticleSystem.MinMaxGradient works the same way for colors, with Color, Gradient, Two Colors, Two Gradients and Random Color modes. For example, to tint props by distance to the road:

[SerializeField] ParticleSystem.MinMaxGradient tintByDistance;

Color tint = tintByDistance.Evaluate(x, r);

• Nothing clamps x for you. Past the last key the curve holds its end value, so an x of 3 reads the same as 1 and nothing warns you. Normalize it yourself. Mathf.InverseLerp is usually all you need.
• Always pass r. Evaluate(x) with one argument uses r = 1, so Two Constants and Two Curves always return the maximum.
• Keep curve keys in 0..1 and use curveMultiplier as the maximum. That's how the curve editor works, and it keeps curves readable when you rebalance.
• Evaluate never rolls r. That's an advantage: you choose the random source, you can seed it, and you can store r per object.
• It lives in the Particle System module. If you've disabled that built-in module in the Package Manager, the type isn't available.

1. Should each instance come out different? If not, use Constant or Curve.
2. Does the range of possible values depend on something else (time, age, distance, level)? If not, Two Constants is enough.

If both answers are yes, you want Two Curves. Some places where that happens:

Massive Swarm System, my swarm asset for Unity, uses this for the values that differ per agent: max speed, acceleration, turn speed and a few more. In version 1.0 each of those fields is a MinMaxCurve with its own r. Each field looks right on its own, but not in combination. An agent can roll a low max speed and a high turn speed, and you get slow shamblers that spin around at full speed.

The fix is the enemy health rule from Demo 2, taken one step further. Each agent rolls one r when it spawns and every field reads that same r, so the slow agents are also the slow turners. The next update does that. It swaps MinMaxCurve for a small struct of its own with the same four modes, so saved profiles load unchanged, and adds a toggle on each field for the ones that should still roll alone.

You can do this with plain MinMaxCurve fields today, since Evaluate takes whatever r you give it. Decide which values should move together and pass them the same r.

Massive Swarm System Runs 1000+ swarm enemies at frame rate in Unity, without DOTS. Built for survivor, bullet-heaven and horde games. Unity 6 Ready See Massive Swarm System →