void RandomizeEnemySpeed(int enemyID)
        {
            // Randomizes speeds of relevant animations in enemy TAE. Also adjusts attack damage based on new speed (excludes Bullets).
            if (enemyID == 0)
            {
                throw new ArgumentException("`RandomizeEnemySpeed` is not for the player.");
            }
            TAE tae = Mod[enemyID].GetTAE(enemyID);

            foreach (var animation in tae.Animations)
            {
                var info = new NPCAnimationInfo(animation, enemyID, Mod);
                if (info.HasInvokeBehaviorEvent && 3000 <= animation.ID && animation.ID <= 3999)
                {
                    RandomizeBehaviorAnimationSpeed(animation, info);
                }
            }
        }
        void RandomizeBehaviorAnimationSpeed(TAE.Animation behaviorAnim, NPCAnimationInfo info, bool isPlayer = false)
        {
            /* Apply random speed modifiers throughout given attack animation (includes behaviors that trigger Bullets and SpEffects).
             *  - The earliest possible time for the hitbox behavior to start is Min(oldStartTime, Max(0.5, 0.5 * oldStartTime, hitboxRadius)).
             *  - The latest possible time for the hitbox is 0.5 * (oldStart - minStart), clamped between [minMax] and [maxMax].
             *  - RoryAlgorithm is more likely to add speed to valid frames that already have more speed, which leads to less noisy functions.
             *  - Hitbox radius of bullets is estimated, but does not take projectile speed into account. Fast, small bullets may see large speed boosts.
             *  - Non-Bullet attack damage is scaled by [minAttackScale] (if earliest possible time) to [maxAttackScale] (if latest possible time), rounded to the nearest 0.1.
             *  - Bullets themselves are unchanged here and randomized separately.
             */
            float hitboxRadius      = 1.0f; // default
            float behaviorStartTime = -1.0f;
            float behaviorEndTime   = -1.0f;

            if (info.InvokeAttackEvent != null)
            {
                Behavior attackBehavior = info.GetAttackBehavior();
                if (attackBehavior == null)
                {
                    return;                          // Missing Behavior param, which means it is most likely unused. No randomization.
                }
                Attack attack = info.GetAttack();
                if (attack == null)
                {
                    return;                  // Missing Attack param, which means it is most likely unused. No randomization.
                }
                hitboxRadius      = attack.Hitbox0Radius;
                behaviorStartTime = info.InvokeAttackEvent.StartTime;
                behaviorEndTime   = info.InvokeAttackEvent.EndTime;
            }
            else if (info.InvokeBulletEvent != null)
            {
                Behavior bulletBehavior = info.GetBulletBehavior();
                if (bulletBehavior == null)
                {
                    return;                          // Missing Behavior param, which means it is most likely unused. No randomization.
                }
                if (bulletBehavior.ReferenceType == 1)
                {
                    Bullet bullet = info.GetBullet();
                    if (bullet == null)
                    {
                        return;                  // Missing Bullet param.
                    }
                    hitboxRadius = Tools.GuessBulletRadius(bullet, Mod);
                    // Console.WriteLine($"    Final bullet ({bullet.ID}) radius of animation {behaviorAnim.ID}: {hitboxRadius:0.00}");
                    if (hitboxRadius == -1.0f)
                    {
                        hitboxRadius = 1.0f;                         // default for bullets with no final radius
                    }
                }
                else if (bulletBehavior.ReferenceType == 2)
                {
                    SpEffect spEffect = info.GetSpEffect();
                    if (spEffect == null)
                    {
                        return;           // Missing SpEffect param.
                    }
                    hitboxRadius = 1.0f;  // leave as default for SpEffect
                }
                behaviorStartTime = info.InvokeBulletEvent.StartTime;
                behaviorEndTime   = info.InvokeBulletEvent.EndTime;
            }
            if (behaviorStartTime == -1.0f || behaviorEndTime == -1.0f)
            {
                throw new ArgumentException($"Behavior start/end times were not set.");
            }

            float      minBehaviorStartTime   = Math.Min(behaviorStartTime, Math.Max(0.5f, Math.Max(0.5f * behaviorStartTime, MinAttackBehaviorHitboxScalar * hitboxRadius)));
            float      maxBehaviorStartTime   = behaviorStartTime + Math.Max(MinMaxAttackBehaviorDelay, Math.Min(0.5f * (behaviorStartTime - minBehaviorStartTime), MaxMaxAttackBehaviorDelay));
            float      newBehaviorStartTime   = minBehaviorStartTime + (float)Rand.NextDouble() * (maxBehaviorStartTime - minBehaviorStartTime);
            List <int> preAttackSpeedFunction = GetRandomSpeedFunction(0.0f, behaviorStartTime, newBehaviorStartTime);

            ApplySpeedFunction(behaviorAnim, preAttackSpeedFunction);
            if (DEBUG)
            {
                Console.WriteLine($"\nANIMATION {behaviorAnim.ID}");
                Console.WriteLine($"    Attack start time: {behaviorStartTime} => {newBehaviorStartTime}");
                Console.WriteLine($"    Random min/max: {minBehaviorStartTime}, {maxBehaviorStartTime}");
                Tools.DrawSpeedFunction(preAttackSpeedFunction, MaxSpeedMultiplier, QuantizedSpeed);
            }
            if (info.InvokeAttackEvent != null)
            {
                float attackPowerFactor      = (newBehaviorStartTime - minBehaviorStartTime) / (maxBehaviorStartTime - minBehaviorStartTime);
                float attackDamageMultiplier = MinAttackScale + attackPowerFactor * (MaxAttackScale - MinAttackScale);
                ApplySpeedAttackDamageMultiplier(behaviorAnim, attackDamageMultiplier, behaviorStartTime - FrameDuration, behaviorEndTime + FrameDuration);
            }
            // Mild random speed change during InvokeBehaviorEvent itself (multiplier of 1.0, 1.1, or 1.2).
            int   duringSpeedOptionCount = (int)(0.2f / QuantizedSpeed) + 1;
            float duringAttackSpeed      = 1.0f + (Rand.Next(duringSpeedOptionCount) * QuantizedSpeed);
            int   duringSpEffectID       = SpeedEffects[(float)Math.Round(duringAttackSpeed, 2)];

            behaviorAnim.ApplyEffect(duringSpEffectID, behaviorStartTime, behaviorEndTime);

            // Post-attack speed function (if cancel event is present to approximate end of animation).
            if (info.AnimationCancelEventEnd != -1.0f)
            {
                float animationEndTime    = info.AnimationCancelEventEnd;
                float minEndRealTime      = behaviorEndTime + (0.5f * (animationEndTime - behaviorEndTime));
                float maxEndRealTime      = behaviorEndTime + (1.3f * (animationEndTime - behaviorEndTime));
                float newAnimationEndTime = minEndRealTime + (float)Rand.NextDouble() * (maxEndRealTime - minEndRealTime);
                if (DEBUG)
                {
                    Console.WriteLine($"    Attack end time: {behaviorEndTime} (before pre-attack speed change)");
                    Console.WriteLine($"    Animation end time: {animationEndTime} => {newAnimationEndTime}");
                    Console.WriteLine($"    Random min/max: {minEndRealTime}, {maxEndRealTime}");
                }
                List <int> postAttackSpeedFunction = GetRandomSpeedFunction(behaviorEndTime, animationEndTime, newAnimationEndTime);
                ApplySpeedFunction(behaviorAnim, postAttackSpeedFunction);
            }
        }