@rian8337/osu-difficulty-calculator 4.0.0-beta.50 → 4.0.0-beta.52

package/dist/index.js

@@ -2,33 +2,6 @@
 
 var osuBase = require('@rian8337/osu-base');
 
-/**
- * An evaluator for calculating aim skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-class AimEvaluator {
-    /**
-     * Calculates the bonus of wide angles.
-     */
-    static calculateWideAngleBonus(angle) {
-        return Math.pow(Math.sin((3 / 4) *
-            (Math.min((5 / 6) * Math.PI, Math.max(Math.PI / 6, angle)) -
-                Math.PI / 6)), 2);
-    }
-    /**
-     * Calculates the bonus of acute angles.
-     */
-    static calculateAcuteAngleBonus(angle) {
-        return 1 - this.calculateWideAngleBonus(angle);
-    }
-}
-AimEvaluator.wideAngleMultiplier = 1.5;
-AimEvaluator.acuteAngleMultiplier = 1.95;
-AimEvaluator.sliderMultiplier = 1.35;
-AimEvaluator.velocityChangeMultiplier = 0.75;
-AimEvaluator.wiggleMultiplier = 1.02;
-
 /**
  * The base of a difficulty calculator.
  */
@@ -314,10 +287,10 @@ class DifficultyHitObject {
      * Calculates the opacity of the hitobject at a given time.
      *
      * @param time The time to calculate the hitobject's opacity at.
-     * @param isHidden Whether Hidden mod is used.
+     * @param mods The mods used.
      * @returns The opacity of the hitobject at the given time.
      */
-    opacityAt(time, isHidden) {
+    opacityAt(time, mods) {
         if (time > this.object.startTime) {
             // Consider a hitobject as being invisible when its start time is passed.
             // In reality the hitobject will be visible beyond its start time up until its hittable window has passed,
@@ -326,7 +299,7 @@ class DifficultyHitObject {
         }
         const fadeInStartTime = this.object.startTime - this.object.timePreempt;
         const fadeInDuration = this.object.timeFadeIn;
-        if (isHidden) {
+        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
             const fadeOutStartTime = fadeInStartTime + fadeInDuration;
             const fadeOutDuration = this.object.timePreempt * osuBase.ModHidden.fadeOutDurationMultiplier;
             return Math.min(osuBase.MathUtils.clamp((time - fadeInStartTime) / fadeInDuration, 0, 1), 1 -
@@ -424,6 +397,36 @@ class DifficultyHitObject {
         if (slider.lazyEndPosition) {
             return;
         }
+        let trackingEndTime = slider.endTime;
+        let { nestedHitObjects: nestedObjects } = slider;
+        if (this.mode === osuBase.Modes.osu) {
+            trackingEndTime = Math.max(slider.endTime - osuBase.Slider.legacyLastTickOffset, slider.startTime + slider.duration / 2);
+            let lastRealTick = null;
+            for (let i = nestedObjects.length - 2; i > 0; --i) {
+                const current = nestedObjects[i];
+                if (current instanceof osuBase.SliderTick) {
+                    lastRealTick = current;
+                    break;
+                }
+                if (current instanceof osuBase.SliderRepeat) {
+                    // A repeat means the slider does not have a slider tick.
+                    break;
+                }
+            }
+            if (lastRealTick && lastRealTick.startTime > trackingEndTime) {
+                trackingEndTime = lastRealTick.startTime;
+                // When the last tick falls after the tracking end time, we need to re-sort the nested objects
+                // based on time. This creates a somewhat weird ordering which is counter to how a user would
+                // understand the slider, but allows a zero-diff with known diffcalc output.
+                //
+                // To reiterate, this is definitely not correct from a difficulty calculation perspective
+                // and should be revisited at a later date.
+                const reordered = nestedObjects.slice();
+                reordered.splice(reordered.indexOf(lastRealTick), 1);
+                reordered.push(lastRealTick);
+                nestedObjects = reordered;
+            }
+        }
         if (this.mode === osuBase.Modes.droid) {
             // Temporary lazy end position until a real result can be derived.
             slider.lazyEndPosition = slider.getStackedPosition(this.mode);
@@ -433,9 +436,7 @@ class DifficultyHitObject {
                 return;
             }
         }
-        // Not using slider.endTime due to legacy last tick offset.
-        slider.lazyTravelTime =
-            slider.nestedHitObjects.at(-1).startTime - slider.startTime;
+        slider.lazyTravelTime = trackingEndTime - slider.startTime;
         let endTimeMin = slider.lazyTravelTime / slider.spanDuration;
         if (endTimeMin % 2 >= 1) {
             endTimeMin = 1 - (endTimeMin % 1);
@@ -449,15 +450,15 @@ class DifficultyHitObject {
             .add(slider.path.positionAt(endTimeMin));
         let currentCursorPosition = slider.getStackedPosition(this.mode);
         const scalingFactor = DifficultyHitObject.normalizedRadius / slider.radius;
-        for (let i = 1; i < slider.nestedHitObjects.length; ++i) {
-            const currentMovementObject = slider.nestedHitObjects[i];
+        for (let i = 1; i < nestedObjects.length; ++i) {
+            const currentMovementObject = nestedObjects[i];
             let currentMovement = currentMovementObject
                 .getStackedPosition(this.mode)
                 .subtract(currentCursorPosition);
             let currentMovementLength = scalingFactor * currentMovement.length;
             // The amount of movement required so that the cursor position needs to be updated.
             let requiredMovement = this.assumedSliderRadius;
-            if (i === slider.nestedHitObjects.length - 1) {
+            if (i === nestedObjects.length - 1) {
                 // The end of a slider has special aim rules due to the relaxed time constraint on position.
                 // There is both a lazy end position as well as the actual end slider position. We assume the player takes the simpler movement.
                 // For sliders that are circular, the lazy end position may actually be farther away than the sliders' true end.
@@ -482,7 +483,7 @@ class DifficultyHitObject {
                         currentMovementLength;
                 slider.lazyTravelDistance += currentMovementLength;
             }
-            if (i === slider.nestedHitObjects.length - 1) {
+            if (i === nestedObjects.length - 1) {
                 slider.lazyEndPosition = currentCursorPosition;
             }
         }
@@ -581,6 +582,14 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
         super.computeProperties(clockRate, hitObjects);
         this.setVisuals(clockRate, hitObjects);
     }
+    opacityAt(time, mods) {
+        // Traceable hides the primary piece of a hit circle (that is, its body), so consider it as fully invisible.
+        if (this.object instanceof osuBase.Circle &&
+            mods.some((m) => m instanceof osuBase.ModTraceable)) {
+            return 0;
+        }
+        return super.opacityAt(time, mods);
+    }
     /**
      * Determines whether this hitobject is considered overlapping with the hitobject before it.
      *
@@ -705,7 +714,7 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
 /**
  * An evaluator for calculating osu!droid Aim skill.
  */
-class DroidAimEvaluator extends AimEvaluator {
+class DroidAimEvaluator {
     /**
      * Evaluates the difficulty of aiming the current object, based on:
      *
@@ -773,8 +782,7 @@ class DroidAimEvaluator extends AimEvaluator {
         Math.max(current.strainTime, last.strainTime) <
             1.25 * Math.min(current.strainTime, last.strainTime) &&
             current.angle !== null &&
-            last.angle !== null &&
-            lastLast.angle !== null) {
+            last.angle !== null) {
             const currentAngle = current.angle;
             const lastAngle = last.angle;
             // Rewarding angles, take the smaller velocity as base.
@@ -869,6 +877,7 @@ DroidAimEvaluator.wideAngleMultiplier = 1.5;
 DroidAimEvaluator.acuteAngleMultiplier = 2.6;
 DroidAimEvaluator.sliderMultiplier = 1.35;
 DroidAimEvaluator.velocityChangeMultiplier = 0.75;
+DroidAimEvaluator.wiggleMultiplier = 1.02;
 DroidAimEvaluator.singleSpacingThreshold = 100;
 // 200 1/4 BPM delta time
 DroidAimEvaluator.minSpeedBonus = 75;
@@ -1034,7 +1043,7 @@ class DroidAim extends DroidSkill {
         if (this.sliderStrains.length === 0) {
             return 0;
         }
-        const maxSliderStrain = Math.max(...this.sliderStrains);
+        const maxSliderStrain = osuBase.MathUtils.max(this.sliderStrains);
         if (maxSliderStrain === 0) {
             return 0;
         }
@@ -1072,20 +1081,10 @@ class DroidAim extends DroidSkill {
     }
 }
 
-/**
- * An evaluator for calculating speed or tap skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-class SpeedEvaluator {
-}
-// ~200 1/4 BPM streams
-SpeedEvaluator.minSpeedBonus = 75;
-
 /**
  * An evaluator for calculating osu!droid tap skill.
  */
-class DroidTapEvaluator extends SpeedEvaluator {
+class DroidTapEvaluator {
     /**
      * Evaluates the difficulty of tapping the current object, based on:
      *
@@ -1122,6 +1121,8 @@ class DroidTapEvaluator extends SpeedEvaluator {
         return (speedBonus * Math.pow(doubletapness, 1.5) * 1000) / strainTime;
     }
 }
+// ~200 1/4 BPM streams
+DroidTapEvaluator.minSpeedBonus = 75;
 
 /**
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
@@ -1153,7 +1154,7 @@ class DroidTap extends DroidSkill {
         if (this._objectStrains.length === 0) {
             return 0;
         }
-        const maxStrain = Math.max(...this._objectStrains);
+        const maxStrain = osuBase.MathUtils.max(this._objectStrains);
         if (maxStrain === 0) {
             return 0;
         }
@@ -1166,7 +1167,7 @@ class DroidTap extends DroidSkill {
         if (this._objectStrains.length === 0) {
             return 0;
         }
-        const maxStrain = Math.max(...this._objectStrains);
+        const maxStrain = osuBase.MathUtils.max(this._objectStrains);
         if (maxStrain === 0) {
             return 0;
         }
@@ -1212,23 +1213,10 @@ class DroidTap extends DroidSkill {
     }
 }
 
-/**
- * An evaluator for calculating flashlight skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-class FlashlightEvaluator {
-}
-FlashlightEvaluator.maxOpacityBonus = 0.4;
-FlashlightEvaluator.hiddenBonus = 0.2;
-FlashlightEvaluator.minVelocity = 0.5;
-FlashlightEvaluator.sliderMultiplier = 1.3;
-FlashlightEvaluator.minAngleMultiplier = 0.2;
-
 /**
  * An evaluator for calculating osu!droid Flashlight skill.
  */
-class DroidFlashlightEvaluator extends FlashlightEvaluator {
+class DroidFlashlightEvaluator {
     /**
      * Evaluates the difficulty of memorizing and hitting the current object, based on:
      *
@@ -1239,10 +1227,10 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
      * - and whether Hidden mod is enabled.
      *
      * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
+     * @param mods The mods used.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current, isHiddenMod, withSliders) {
+    static evaluateDifficultyOf(current, mods, withSliders) {
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
             current.isOverlapping(true)) {
@@ -1273,7 +1261,7 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
                 const opacityBonus = 1 +
                     this.maxOpacityBonus *
                         (1 -
-                            current.opacityAt(currentObject.object.startTime, isHiddenMod));
+                            current.opacityAt(currentObject.object.startTime, mods));
                 result +=
                     (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
                         cumulativeStrainTime;
@@ -1288,9 +1276,20 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
         }
         result = Math.pow(smallDistNerf * result, 2);
         // Additional bonus for Hidden due to there being no approach circles.
-        if (isHiddenMod) {
+        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
             result *= 1 + this.hiddenBonus;
         }
+        else if (mods.some((m) => m instanceof osuBase.ModTraceable)) {
+            // Additional bonus for Traceable due to there being no primary or secondary object pieces.
+            if (current.object instanceof osuBase.Circle) {
+                // Additional bonus for hit circles due to there being no circle piece, which is the primary piece.
+                result *= 1 + this.traceableCircleBonus;
+            }
+            else {
+                // The rest of the objects only hide secondary pieces.
+                result *= 1 + this.traceableObjectBonus;
+            }
+        }
         // Nerf patterns with repeated angles.
         result *=
             this.minAngleMultiplier +
@@ -1311,6 +1310,13 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
         return result;
     }
 }
+DroidFlashlightEvaluator.maxOpacityBonus = 0.4;
+DroidFlashlightEvaluator.hiddenBonus = 0.2;
+DroidFlashlightEvaluator.traceableCircleBonus = 0.15;
+DroidFlashlightEvaluator.traceableObjectBonus = 0.1;
+DroidFlashlightEvaluator.minVelocity = 0.5;
+DroidFlashlightEvaluator.sliderMultiplier = 1.3;
+DroidFlashlightEvaluator.minAngleMultiplier = 0.2;
 
 /**
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
@@ -1324,13 +1330,12 @@ class DroidFlashlight extends DroidSkill {
         this.starsPerDouble = 1.06;
         this.skillMultiplier = 0.02;
         this.currentFlashlightStrain = 0;
-        this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
         this.withSliders = withSliders;
     }
     strainValueAt(current) {
         this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
         this.currentFlashlightStrain +=
-            DroidFlashlightEvaluator.evaluateDifficultyOf(current, this.isHidden, this.withSliders) * this.skillMultiplier;
+            DroidFlashlightEvaluator.evaluateDifficultyOf(current, this.mods, this.withSliders) * this.skillMultiplier;
         return this.currentFlashlightStrain;
     }
     calculateInitialStrain(time, current) {
@@ -1597,22 +1602,31 @@ class DroidVisualEvaluator {
      * - and whether the Hidden mod is enabled.
      *
      * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
+     * @param mods The mods used.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current, isHiddenMod, withSliders) {
+    static evaluateDifficultyOf(current, mods, withSliders) {
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
             current.isOverlapping(true) ||
             current.index === 0) {
             return 0;
         }
-        // Start with base density and give global bonus for Hidden.
+        // Start with base density and give global bonus for Hidden and Traceable.
         // Add density caps for sanity.
         let strain;
-        if (isHiddenMod) {
+        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
             strain = Math.min(30, Math.pow(current.noteDensity, 3));
         }
+        else if (mods.some((m) => m instanceof osuBase.ModTraceable)) {
+            // Give more bonus for hit circles due to there being no circle piece.
+            if (current.object instanceof osuBase.Circle) {
+                strain = Math.min(25, Math.pow(current.noteDensity, 2.5));
+            }
+            else {
+                strain = Math.min(22.5, Math.pow(current.noteDensity, 2.25));
+            }
+        }
         else {
             strain = Math.min(20, Math.pow(current.noteDensity, 2));
         }
@@ -1630,9 +1644,7 @@ class DroidVisualEvaluator {
                 break;
             }
             strain +=
-                (1 -
-                    current.opacityAt(previous.object.startTime, isHiddenMod)) /
-                    4;
+                (1 - current.opacityAt(previous.object.startTime, mods)) / 4;
         }
         if (current.timePreempt < 400) {
             // Give bonus for AR higher than 10.33.
@@ -1692,13 +1704,12 @@ class DroidVisual extends DroidSkill {
         this.currentVisualStrain = 0;
         this.currentRhythmMultiplier = 1;
         this.skillMultiplier = 10;
-        this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
         this.withSliders = withSliders;
     }
     strainValueAt(current) {
         this.currentVisualStrain *= this.strainDecay(current.deltaTime);
         this.currentVisualStrain +=
-            DroidVisualEvaluator.evaluateDifficultyOf(current, this.isHidden, this.withSliders) * this.skillMultiplier;
+            DroidVisualEvaluator.evaluateDifficultyOf(current, this.mods, this.withSliders) * this.skillMultiplier;
         this.currentRhythmMultiplier = current.rhythmMultiplier;
         return this.currentVisualStrain * this.currentRhythmMultiplier;
     }
@@ -1802,6 +1813,10 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
     calculateAim() {
+        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            this.attributes.aimDifficulty = 0;
+            return;
+        }
         const aimSkill = new DroidAim(this.mods, true);
         const aimSkillWithoutSliders = new DroidAim(this.mods, false);
         this.calculateSkills(aimSkill, aimSkillWithoutSliders);
@@ -1811,6 +1826,10 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * Calculates the tap star rating of the beatmap and stores it in this instance.
      */
     calculateTap() {
+        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            this.attributes.tapDifficulty = 0;
+            return;
+        }
         const tapSkillCheese = new DroidTap(this.mods, true);
         const tapSkillNoCheese = new DroidTap(this.mods, false);
         this.calculateSkills(tapSkillCheese, tapSkillNoCheese);
@@ -1830,6 +1849,10 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * Calculates the flashlight star rating of the beatmap and stores it in this instance.
      */
     calculateFlashlight() {
+        if (!this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            this.attributes.flashlightDifficulty = 0;
+            return;
+        }
         const flashlightSkill = new DroidFlashlight(this.mods, true);
         const flashlightSkillWithoutSliders = new DroidFlashlight(this.mods, false);
         this.calculateSkills(flashlightSkill, flashlightSkillWithoutSliders);
@@ -1874,21 +1897,29 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     calculateAll() {
         const skills = this.createSkills();
         this.calculateSkills(...skills);
-        const aimSkill = skills[0];
-        const aimSkillWithoutSliders = skills[1];
-        const rhythmSkill = skills[2];
-        const tapSkillCheese = skills[3];
-        const flashlightSkill = skills[5];
-        const flashlightSkillWithoutSliders = skills[6];
-        const visualSkill = skills[7];
-        const visualSkillWithoutSliders = skills[8];
-        const tapSkillVibro = new DroidTap(this.mods, true, tapSkillCheese.relevantDeltaTime());
-        this.calculateSkills(tapSkillVibro);
-        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
-        this.postCalculateTap(tapSkillCheese, tapSkillVibro);
+        const aimSkill = skills.find((s) => s instanceof DroidAim && s.withSliders);
+        const aimSkillWithoutSliders = skills.find((s) => s instanceof DroidAim && !s.withSliders);
+        const rhythmSkill = skills.find((s) => s instanceof DroidRhythm);
+        const tapSkillCheese = skills.find((s) => s instanceof DroidTap && s.considerCheesability);
+        const flashlightSkill = skills.find((s) => s instanceof DroidFlashlight && s.withSliders);
+        const flashlightSkillWithoutSliders = skills.find((s) => s instanceof DroidFlashlight && !s.withSliders);
+        const visualSkill = skills.find((s) => s instanceof DroidVisual && s.withSliders);
+        const visualSkillWithoutSliders = skills.find((s) => s instanceof DroidVisual && !s.withSliders);
+        if (aimSkill && aimSkillWithoutSliders) {
+            this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
+        }
+        if (tapSkillCheese) {
+            const tapSkillVibro = new DroidTap(this.mods, true, tapSkillCheese.relevantDeltaTime());
+            this.calculateSkills(tapSkillVibro);
+            this.postCalculateTap(tapSkillCheese, tapSkillVibro);
+        }
         this.postCalculateRhythm(rhythmSkill);
-        this.postCalculateFlashlight(flashlightSkill, flashlightSkillWithoutSliders);
-        this.postCalculateVisual(visualSkill, visualSkillWithoutSliders);
+        if (flashlightSkill && flashlightSkillWithoutSliders) {
+            this.postCalculateFlashlight(flashlightSkill, flashlightSkillWithoutSliders);
+        }
+        if (visualSkill && visualSkillWithoutSliders) {
+            this.postCalculateVisual(visualSkill, visualSkillWithoutSliders);
+        }
         this.calculateTotal();
     }
     toString() {
@@ -1917,20 +1948,24 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         return difficultyObjects;
     }
     createSkills() {
-        return [
-            new DroidAim(this.mods, true),
-            new DroidAim(this.mods, false),
-            // Tap skill depends on rhythm skill, so we put it first
-            new DroidRhythm(this.mods),
-            // Cheesability tap
-            new DroidTap(this.mods, true),
-            // Non-cheesability tap
-            new DroidTap(this.mods, false),
-            new DroidFlashlight(this.mods, true),
-            new DroidFlashlight(this.mods, false),
-            new DroidVisual(this.mods, true),
-            new DroidVisual(this.mods, false),
-        ];
+        const skills = [];
+        if (!this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            skills.push(new DroidAim(this.mods, true));
+            skills.push(new DroidAim(this.mods, false));
+        }
+        if (!this.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            // Tap and visual skills depend on rhythm skill, so we put it first
+            skills.push(new DroidRhythm(this.mods));
+            skills.push(new DroidTap(this.mods, true));
+            skills.push(new DroidTap(this.mods, false));
+            skills.push(new DroidVisual(this.mods, true));
+            skills.push(new DroidVisual(this.mods, false));
+        }
+        if (this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            skills.push(new DroidFlashlight(this.mods, true));
+            skills.push(new DroidFlashlight(this.mods, false));
+        }
+        return skills;
     }
     calculateClockRate(options) {
         var _a, _b;
@@ -2882,10 +2917,40 @@ class OsuSkill extends StrainSkill {
     }
 }
 
+/**
+ * Represents an osu!standard hit object with difficulty calculation values.
+ */
+class OsuDifficultyHitObject extends DifficultyHitObject {
+    constructor() {
+        super(...arguments);
+        /**
+         * The speed strain generated by the hitobject.
+         */
+        this.speedStrain = 0;
+        /**
+         * The flashlight strain generated by this hitobject.
+         */
+        this.flashlightStrain = 0;
+        this.radiusBuffThreshold = 30;
+        this.mode = osuBase.Modes.osu;
+    }
+    get scalingFactor() {
+        const radius = this.object.radius;
+        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
+        let scalingFactor = DifficultyHitObject.normalizedRadius / radius;
+        // High circle size (small CS) bonus
+        if (radius < this.radiusBuffThreshold) {
+            scalingFactor *=
+                1 + Math.min(this.radiusBuffThreshold - radius, 5) / 50;
+        }
+        return scalingFactor;
+    }
+}
+
 /**
  * An evaluator for calculating osu!standard Aim skill.
  */
-class OsuAimEvaluator extends AimEvaluator {
+class OsuAimEvaluator {
     /**
      * Evaluates the difficulty of aiming the current object, based on:
      *
@@ -2905,6 +2970,8 @@ class OsuAimEvaluator extends AimEvaluator {
             return 0;
         }
         const lastLast = current.previous(1);
+        const radius = OsuDifficultyHitObject.normalizedRadius;
+        const diameter = OsuDifficultyHitObject.normalizedDiameter;
         // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
         let currentVelocity = current.lazyJumpDistance / current.strainTime;
         // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
@@ -2927,6 +2994,7 @@ class OsuAimEvaluator extends AimEvaluator {
         let acuteAngleBonus = 0;
         let sliderBonus = 0;
         let velocityChangeBonus = 0;
+        let wiggleBonus = 0;
         // Start strain with regular velocity.
         let strain = currentVelocity;
         if (
@@ -2934,42 +3002,41 @@ class OsuAimEvaluator extends AimEvaluator {
         Math.max(current.strainTime, last.strainTime) <
             1.25 * Math.min(current.strainTime, last.strainTime) &&
             current.angle !== null &&
-            last.angle !== null &&
-            lastLast.angle !== null) {
+            last.angle !== null) {
+            const currentAngle = current.angle;
+            const lastAngle = last.angle;
             // Rewarding angles, take the smaller velocity as base.
             const angleBonus = Math.min(currentVelocity, prevVelocity);
             wideAngleBonus = this.calculateWideAngleBonus(current.angle);
             acuteAngleBonus = this.calculateAcuteAngleBonus(current.angle);
-            // Only buff deltaTime exceeding 300 BPM 1/2.
-            if (current.strainTime > 100) {
-                acuteAngleBonus = 0;
-            }
-            else {
-                acuteAngleBonus *=
-                    // Multiply by previous angle, we don't want to buff unless this is a wiggle type pattern.
-                    this.calculateAcuteAngleBonus(last.angle) *
-                        // The maximum velocity we buff is equal to 125 / strainTime.
-                        Math.min(angleBonus, 125 / current.strainTime) *
-                        // Scale buff from 300 BPM 1/2 to 400 BPM 1/2.
-                        Math.pow(Math.sin((Math.PI / 2) *
-                            Math.min(1, (100 - current.strainTime) / 25)), 2) *
-                        // Buff distance exceeding 50 (radius) up to 100 (diameter).
-                        Math.pow(Math.sin(((Math.PI / 2) *
-                            (osuBase.MathUtils.clamp(current.lazyJumpDistance, 50, 100) -
-                                50)) /
-                            50), 2);
-            }
-            // Penalize wide angles if they're repeated, reducing the penalty as last.angle gets more acute.
+            // Penalize angle repetition.
             wideAngleBonus *=
-                angleBonus *
-                    (1 -
-                        Math.min(wideAngleBonus, Math.pow(this.calculateWideAngleBonus(last.angle), 3)));
-            // Penalize acute angles if they're repeated, reducing the penalty as lastLast.angle gets more obtuse.
+                1 -
+                    Math.min(wideAngleBonus, Math.pow(this.calculateWideAngleBonus(lastAngle), 3));
             acuteAngleBonus *=
-                0.5 +
-                    0.5 *
+                0.08 +
+                    0.92 *
                         (1 -
-                            Math.min(acuteAngleBonus, Math.pow(this.calculateAcuteAngleBonus(lastLast.angle), 3)));
+                            Math.min(acuteAngleBonus, Math.pow(this.calculateAcuteAngleBonus(lastAngle), 3)));
+            // Apply full wide angle bonus for distance more than one diameter
+            wideAngleBonus *=
+                angleBonus *
+                    osuBase.MathUtils.smootherstep(current.lazyJumpDistance, 0, diameter);
+            // Apply acute angle bonus for BPM above 300 1/2 and distance more than one diameter
+            acuteAngleBonus *=
+                angleBonus *
+                    osuBase.MathUtils.smootherstep(osuBase.MathUtils.millisecondsToBPM(current.strainTime, 2), 300, 400) *
+                    osuBase.MathUtils.smootherstep(current.lazyJumpDistance, diameter, diameter * 2);
+            // Apply wiggle bonus for jumps that are [radius, 3*diameter] in distance, with < 110 angle
+            // https://www.desmos.com/calculator/dp0v0nvowc
+            wiggleBonus =
+                angleBonus *
+                    osuBase.MathUtils.smootherstep(current.lazyJumpDistance, radius, diameter) *
+                    Math.pow(osuBase.MathUtils.reverseLerp(current.lazyJumpDistance, diameter * 3, diameter), 1.8) *
+                    osuBase.MathUtils.smootherstep(currentAngle, osuBase.MathUtils.degreesToRadians(110), osuBase.MathUtils.degreesToRadians(60)) *
+                    osuBase.MathUtils.smootherstep(last.lazyJumpDistance, radius, diameter) *
+                    Math.pow(osuBase.MathUtils.reverseLerp(last.lazyJumpDistance, diameter * 3, diameter), 1.8) *
+                    osuBase.MathUtils.smootherstep(lastAngle, osuBase.MathUtils.degreesToRadians(110), osuBase.MathUtils.degreesToRadians(60));
         }
         if (Math.max(prevVelocity, currentVelocity)) {
             // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
@@ -2993,6 +3060,7 @@ class OsuAimEvaluator extends AimEvaluator {
             // Reward sliders based on velocity.
             sliderBonus = last.travelDistance / last.travelTime;
         }
+        strain += wiggleBonus * this.wiggleMultiplier;
         // Add in acute angle bonus or wide angle bonus + velocity change bonus, whichever is larger.
         strain += Math.max(acuteAngleBonus * this.acuteAngleMultiplier, wideAngleBonus * this.wideAngleMultiplier +
             velocityChangeBonus * this.velocityChangeMultiplier);
@@ -3002,7 +3070,18 @@ class OsuAimEvaluator extends AimEvaluator {
         }
         return strain;
     }
+    static calculateWideAngleBonus(angle) {
+        return osuBase.MathUtils.smoothstep(angle, osuBase.MathUtils.degreesToRadians(40), osuBase.MathUtils.degreesToRadians(140));
+    }
+    static calculateAcuteAngleBonus(angle) {
+        return osuBase.MathUtils.smoothstep(angle, osuBase.MathUtils.degreesToRadians(140), osuBase.MathUtils.degreesToRadians(40));
+    }
 }
+OsuAimEvaluator.wideAngleMultiplier = 1.5;
+OsuAimEvaluator.acuteAngleMultiplier = 2.6;
+OsuAimEvaluator.sliderMultiplier = 1.35;
+OsuAimEvaluator.velocityChangeMultiplier = 0.75;
+OsuAimEvaluator.wiggleMultiplier = 1.02;
 
 /**
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
@@ -3015,15 +3094,33 @@ class OsuAim extends OsuSkill {
         this.reducedSectionBaseline = 0.75;
         this.decayWeight = 0.9;
         this.currentAimStrain = 0;
-        this.skillMultiplier = 25.18;
+        this.skillMultiplier = 25.6;
+        this.sliderStrains = [];
         this.withSliders = withSliders;
     }
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
+     */
+    countDifficultSliders() {
+        if (this.sliderStrains.length === 0) {
+            return 0;
+        }
+        const maxSliderStrain = osuBase.MathUtils.max(this.sliderStrains);
+        if (maxSliderStrain === 0) {
+            return 0;
+        }
+        return this.sliderStrains.reduce((total, strain) => total +
+            1 / (1 + Math.exp(-((strain / maxSliderStrain) * 12 - 6))), 0);
+    }
     strainValueAt(current) {
         this.currentAimStrain *= this.strainDecay(current.deltaTime);
         this.currentAimStrain +=
             OsuAimEvaluator.evaluateDifficultyOf(current, this.withSliders) *
                 this.skillMultiplier;
         this._objectStrains.push(this.currentAimStrain);
+        if (current.object instanceof osuBase.Slider) {
+            this.sliderStrains.push(this.currentAimStrain);
+        }
         return this.currentAimStrain;
     }
     calculateInitialStrain(time, current) {
@@ -3047,7 +3144,7 @@ class OsuAim extends OsuSkill {
 /**
  * An evaluator for calculating osu!standard speed skill.
  */
-class OsuSpeedEvaluator extends SpeedEvaluator {
+class OsuSpeedEvaluator {
     /**
      * Evaluates the difficulty of tapping the current object, based on:
      *
@@ -3056,8 +3153,9 @@ class OsuSpeedEvaluator extends SpeedEvaluator {
      * - and how easily they can be cheesed.
      *
      * @param current The current object.
+     * @param mods The mods applied.
      */
-    static evaluateDifficultyOf(current) {
+    static evaluateDifficultyOf(current, mods) {
         var _a;
         if (current.object instanceof osuBase.Spinner) {
             return 0;
@@ -3080,8 +3178,11 @@ class OsuSpeedEvaluator extends SpeedEvaluator {
         // Cap distance at spacing threshold
         const distance = Math.min(this.SINGLE_SPACING_THRESHOLD, travelDistance + current.minimumJumpDistance);
         // Max distance bonus is 1 * `distance_multiplier` at single_spacing_threshold
-        const distanceBonus = Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 3.95) *
+        let distanceBonus = Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 3.95) *
             this.DISTANCE_MULTIPLIER;
+        if (mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            distanceBonus = 0;
+        }
         // Base difficulty with all bonuses
         const difficulty = ((1 + speedBonus + distanceBonus) * 1000) / strainTime;
         // Apply penalty if there's doubletappable doubles
@@ -3094,7 +3195,9 @@ class OsuSpeedEvaluator extends SpeedEvaluator {
  * About 1.25 circles distance between hitobject centers.
  */
 OsuSpeedEvaluator.SINGLE_SPACING_THRESHOLD = 125;
-OsuSpeedEvaluator.DISTANCE_MULTIPLIER = 0.94;
+// ~200 1/4 BPM streams
+OsuSpeedEvaluator.minSpeedBonus = 75;
+OsuSpeedEvaluator.DISTANCE_MULTIPLIER = 0.9;
 
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
@@ -3196,7 +3299,7 @@ class OsuRhythmEvaluator {
                         }
                         // Repeated island (ex: triplet -> triplet).
                         // Graph: https://www.desmos.com/calculator/pj7an56zwf
-                        effectiveRatio *= Math.min(3 / islandCount, Math.pow(1 / islandCount, 2.75 / (1 + Math.exp(14 - 0.24 * island.delta))));
+                        effectiveRatio *= Math.min(3 / islandCount, Math.pow(1 / islandCount, osuBase.MathUtils.offsetLogistic(island.delta, 58.33, 0.24, 2.75)));
                         break;
                     }
                     if (!islandFound) {
@@ -3256,7 +3359,7 @@ class OsuSpeed extends OsuSkill {
         this.decayWeight = 0.9;
         this.currentSpeedStrain = 0;
         this.currentRhythm = 0;
-        this.skillMultiplier = 1.43;
+        this.skillMultiplier = 1.46;
     }
     /**
      * @param current The hitobject to calculate.
@@ -3264,7 +3367,7 @@ class OsuSpeed extends OsuSkill {
     strainValueAt(current) {
         this.currentSpeedStrain *= this.strainDecay(current.strainTime);
         this.currentSpeedStrain +=
-            OsuSpeedEvaluator.evaluateDifficultyOf(current) *
+            OsuSpeedEvaluator.evaluateDifficultyOf(current, this.mods) *
                 this.skillMultiplier;
         this.currentRhythm = OsuRhythmEvaluator.evaluateDifficultyOf(current);
         const strain = this.currentSpeedStrain * this.currentRhythm;
@@ -3289,7 +3392,7 @@ class OsuSpeed extends OsuSkill {
 /**
  * An evaluator for calculating osu!standard Flashlight skill.
  */
-class OsuFlashlightEvaluator extends FlashlightEvaluator {
+class OsuFlashlightEvaluator {
     /**
      * Evaluates the difficulty of memorizing and hitting the current object, based on:
      *
@@ -3300,9 +3403,9 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
      * - and whether Hidden mod is enabled.
      *
      * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
+     * @param mods The mods used.
      */
-    static evaluateDifficultyOf(current, isHiddenMod) {
+    static evaluateDifficultyOf(current, mods) {
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
@@ -3314,11 +3417,11 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
         let angleRepeatCount = 0;
         for (let i = 0; i < Math.min(current.index, 10); ++i) {
             const currentObject = current.previous(i);
+            cumulativeStrainTime += last.strainTime;
             if (!(currentObject.object instanceof osuBase.Spinner)) {
                 const jumpDistance = current.object
                     .getStackedPosition(osuBase.Modes.osu)
                     .subtract(currentObject.object.getStackedEndPosition(osuBase.Modes.osu)).length;
-                cumulativeStrainTime += last.strainTime;
                 // We want to nerf objects that can be easily seen within the Flashlight circle radius.
                 if (i === 0) {
                     smallDistNerf = Math.min(1, jumpDistance / 75);
@@ -3329,7 +3432,7 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
                 const opacityBonus = 1 +
                     this.maxOpacityBonus *
                         (1 -
-                            current.opacityAt(currentObject.object.startTime, isHiddenMod));
+                            current.opacityAt(currentObject.object.startTime, mods));
                 result +=
                     (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
                         cumulativeStrainTime;
@@ -3344,7 +3447,7 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
         }
         result = Math.pow(smallDistNerf * result, 2);
         // Additional bonus for Hidden due to there being no approach circles.
-        if (isHiddenMod) {
+        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
             result *= 1 + this.hiddenBonus;
         }
         // Nerf patterns with repeated angles.
@@ -3367,20 +3470,24 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
         return result;
     }
 }
+OsuFlashlightEvaluator.maxOpacityBonus = 0.4;
+OsuFlashlightEvaluator.hiddenBonus = 0.2;
+OsuFlashlightEvaluator.minVelocity = 0.5;
+OsuFlashlightEvaluator.sliderMultiplier = 1.3;
+OsuFlashlightEvaluator.minAngleMultiplier = 0.2;
 
 /**
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 class OsuFlashlight extends OsuSkill {
-    constructor(mods) {
-        super(mods);
+    constructor() {
+        super(...arguments);
         this.strainDecayBase = 0.15;
         this.reducedSectionCount = 0;
         this.reducedSectionBaseline = 1;
         this.decayWeight = 1;
         this.currentFlashlightStrain = 0;
         this.skillMultiplier = 0.05512;
-        this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
     }
     difficultyValue() {
         return this.strainPeaks.reduce((a, b) => a + b, 0);
@@ -3388,7 +3495,8 @@ class OsuFlashlight extends OsuSkill {
     strainValueAt(current) {
         this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
         this.currentFlashlightStrain +=
-            OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.isHidden) * this.skillMultiplier;
+            OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.mods) *
+                this.skillMultiplier;
         return this.currentFlashlightStrain;
     }
     calculateInitialStrain(time, current) {
@@ -3401,36 +3509,6 @@ class OsuFlashlight extends OsuSkill {
     }
 }
 
-/**
- * Represents an osu!standard hit object with difficulty calculation values.
- */
-class OsuDifficultyHitObject extends DifficultyHitObject {
-    constructor() {
-        super(...arguments);
-        /**
-         * The speed strain generated by the hitobject.
-         */
-        this.speedStrain = 0;
-        /**
-         * The flashlight strain generated by this hitobject.
-         */
-        this.flashlightStrain = 0;
-        this.radiusBuffThreshold = 30;
-        this.mode = osuBase.Modes.osu;
-    }
-    get scalingFactor() {
-        const radius = this.object.radius;
-        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
-        let scalingFactor = DifficultyHitObject.normalizedRadius / radius;
-        // High circle size (small CS) bonus
-        if (radius < this.radiusBuffThreshold) {
-            scalingFactor *=
-                1 + Math.min(this.radiusBuffThreshold - radius, 5) / 50;
-        }
-        return scalingFactor;
-    }
-}
-
 /**
  * A difficulty calculator for osu!standard gamemode.
  */
@@ -3452,6 +3530,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             hitCircleCount: 0,
             sliderCount: 0,
             spinnerCount: 0,
+            aimDifficultSliderCount: 0,
             aimDifficultStrainCount: 0,
             speedDifficultStrainCount: 0,
         };
@@ -3483,6 +3562,10 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
     calculateAim() {
+        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            this.attributes.aimDifficulty = 0;
+            return;
+        }
         const aimSkill = new OsuAim(this.mods, true);
         const aimSkillWithoutSliders = new OsuAim(this.mods, false);
         this.calculateSkills(aimSkill, aimSkillWithoutSliders);
@@ -3504,6 +3587,10 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
      * Calculates the flashlight star rating of the beatmap and stores it in this instance.
      */
     calculateFlashlight() {
+        if (!this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            this.attributes.flashlightDifficulty = 0;
+            return;
+        }
         const flashlightSkill = new OsuFlashlight(this.mods);
         this.calculateSkills(flashlightSkill);
         this.postCalculateFlashlight(flashlightSkill);
@@ -3533,21 +3620,20 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
     }
     calculateAll() {
         const skills = this.createSkills();
-        const isRelax = this.mods.some((m) => m instanceof osuBase.ModRelax);
         this.calculateSkills(...skills);
-        const aimSkill = skills[0];
-        const aimSkillWithoutSliders = skills[1];
-        const speedSkill = skills[2];
-        const flashlightSkill = skills[3];
-        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
-        if (isRelax) {
-            this.attributes.speedDifficulty = 0;
-        }
-        else {
+        const aimSkill = skills.find((s) => s instanceof OsuAim && s.withSliders);
+        const aimSkillWithoutSliders = skills.find((s) => s instanceof OsuAim && !s.withSliders);
+        const speedSkill = skills.find((s) => s instanceof OsuSpeed);
+        const flashlightSkill = skills.find((s) => s instanceof OsuFlashlight);
+        if (aimSkill && aimSkillWithoutSliders) {
+            this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
+        }
+        if (speedSkill) {
             this.postCalculateSpeed(speedSkill);
         }
-        this.calculateSpeedAttributes();
-        this.postCalculateFlashlight(flashlightSkill);
+        if (flashlightSkill) {
+            this.postCalculateFlashlight(flashlightSkill);
+        }
         this.calculateTotal();
     }
     toString() {
@@ -3572,12 +3658,18 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         return difficultyObjects;
     }
     createSkills() {
-        return [
-            new OsuAim(this.mods, true),
-            new OsuAim(this.mods, false),
-            new OsuSpeed(this.mods),
-            new OsuFlashlight(this.mods),
-        ];
+        const skills = [];
+        if (!this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            skills.push(new OsuAim(this.mods, true));
+            skills.push(new OsuAim(this.mods, false));
+        }
+        if (!this.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            skills.push(new OsuSpeed(this.mods));
+        }
+        if (this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            skills.push(new OsuFlashlight(this.mods));
+        }
+        return skills;
     }
     populateDifficultyAttributes(beatmap, clockRate) {
         super.populateDifficultyAttributes(beatmap, clockRate);
@@ -3605,8 +3697,13 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.attributes.aimDifficulty *= 0.9;
         }
+        else if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            this.attributes.aimDifficulty = 0;
+        }
         this.attributes.aimDifficultStrainCount =
             aimSkill.countDifficultStrains();
+        this.attributes.aimDifficultSliderCount =
+            aimSkill.countDifficultSliders();
     }
     /**
      * Called after speed skill calculation.
@@ -3615,16 +3712,16 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
      */
     postCalculateSpeed(speedSkill) {
         this.strainPeaks.speed = speedSkill.strainPeaks;
-        this.attributes.speedDifficulty = this.starValue(speedSkill.difficultyValue());
+        this.attributes.speedDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
+            ? 0
+            : this.starValue(speedSkill.difficultyValue());
+        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            this.attributes.speedDifficulty *= 0.5;
+        }
         this.attributes.speedDifficultStrainCount =
             speedSkill.countDifficultStrains();
-    }
-    /**
-     * Calculates speed-related attributes.
-     */
-    calculateSpeedAttributes() {
         const objectStrains = this.objects.map((v) => v.speedStrain);
-        const maxStrain = Math.max(...objectStrains);
+        const maxStrain = osuBase.MathUtils.max(objectStrains);
         if (maxStrain) {
             this.attributes.speedNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
         }
@@ -3643,6 +3740,9 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.attributes.flashlightDifficulty *= 0.7;
         }
+        else if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            this.attributes.flashlightDifficulty *= 0.4;
+        }
     }
 }
 
@@ -3671,8 +3771,10 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         this.finalMultiplier = 1.15;
         this.mode = osuBase.Modes.osu;
         this.comboPenalty = 1;
+        this.speedDeviation = 0;
     }
     calculateValues() {
+        this.speedDeviation = this.calculateSpeedDeviation();
         this.aim = this.calculateAimValue();
         this.speed = this.calculateSpeedValue();
         this.accuracy = this.calculateAccuracyValue();
@@ -3696,6 +3798,9 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
      * Calculates the aim performance value of the beatmap.
      */
     calculateAimValue() {
+        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            return 0;
+        }
         let aimValue = this.baseValue(this.difficultyAttributes.aimDifficulty);
         // Longer maps are worth more
         let lengthBonus = 0.95 + 0.4 * Math.min(1, this.totalHits / 2000);
@@ -3703,6 +3808,14 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             lengthBonus += Math.log10(this.totalHits / 2000) * 0.5;
         }
         aimValue *= lengthBonus;
+        if (this.effectiveMissCount > 0) {
+            // Penalize misses by assessing # of misses relative to the total # of objects.
+            // Default a 3% reduction for any # of misses.
+            aimValue *=
+                0.97 *
+                    Math.pow(1 -
+                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
+        }
         aimValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.aimDifficultStrainCount);
         const calculatedAR = this.difficultyAttributes.approachRate;
         if (!this.mods.some((m) => m instanceof osuBase.ModRelax)) {
@@ -3718,7 +3831,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             aimValue *= 1 + arFactor * lengthBonus;
         }
         // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-        if (this.mods.some((m) => m instanceof osuBase.ModHidden)) {
+        if (this.mods.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModTraceable)) {
             aimValue *= 1 + 0.04 * (12 - calculatedAR);
         }
         // Scale the aim value with slider factor to nerf very likely dropped sliderends.
@@ -3734,7 +3847,8 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
      * Calculates the speed performance value of the beatmap.
      */
     calculateSpeedValue() {
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
+        if (this.mods.some((m) => m instanceof osuBase.ModRelax) ||
+            this.speedDeviation === Number.POSITIVE_INFINITY) {
             return 0;
         }
         let speedValue = this.baseValue(this.difficultyAttributes.speedDifficulty);
@@ -3747,11 +3861,12 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         speedValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.speedDifficultStrainCount);
         // AR scaling
         const calculatedAR = this.difficultyAttributes.approachRate;
-        if (calculatedAR > 10.33) {
+        if (calculatedAR > 10.33 &&
+            !this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
             // Buff for longer maps with high AR.
             speedValue *= 1 + 0.3 * (calculatedAR - 10.33) * lengthBonus;
         }
-        if (this.mods.some((m) => m instanceof osuBase.ModHidden)) {
+        if (this.mods.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModTraceable)) {
             speedValue *= 1 + 0.04 * (12 - calculatedAR);
         }
         // Calculate accuracy assuming the worst case scenario.
@@ -3768,16 +3883,15 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             }
             : // Set accuracy to 0.
                 { n300: 0, nobjects: 1 });
+        speedValue *= this.calculateSpeedHighDeviationNerf();
         // Scale the speed value with accuracy and OD.
         speedValue *=
             (0.95 +
-                Math.pow(this.difficultyAttributes.overallDifficulty, 2) /
+                Math.pow(Math.max(0, this.difficultyAttributes.overallDifficulty), 2) /
                     750) *
                 Math.pow((this.computedAccuracy.value() +
                     relevantAccuracy.value(this.difficultyAttributes.speedNoteCount)) /
                     2, (14.5 - this.difficultyAttributes.overallDifficulty) / 2);
-        // Scale the speed value with # of 50s to punish doubletapping.
-        speedValue *= Math.pow(0.99, Math.max(0, this.computedAccuracy.n50 - this.totalHits / 500));
         return speedValue;
     }
     /**
@@ -3802,7 +3916,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             2.83;
         // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
         accuracyValue *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
-        if (this.mods.some((m) => m instanceof osuBase.ModHidden)) {
+        if (this.mods.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModTraceable)) {
             accuracyValue *= 1.08;
         }
         if (this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
@@ -3841,6 +3955,113 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         flashlightValue *= 0.98 + odScaling;
         return flashlightValue;
     }
+    /**
+     * Estimates a player's deviation on speed notes using {@link calculateDeviation}, assuming worst-case.
+     *
+     * Treats all speed notes as hit circles.
+     */
+    calculateSpeedDeviation() {
+        if (this.totalSuccessfulHits === 0) {
+            return Number.POSITIVE_INFINITY;
+        }
+        // Calculate accuracy assuming the worst case scenario
+        const speedNoteCount = this.difficultyAttributes.speedNoteCount +
+            (this.totalHits - this.difficultyAttributes.speedNoteCount) * 0.1;
+        // Assume worst case: all mistakes were on speed notes
+        const relevantCountMiss = Math.min(this.computedAccuracy.nmiss, speedNoteCount);
+        const relevantCountMeh = Math.min(this.computedAccuracy.n50, speedNoteCount - relevantCountMiss);
+        const relevantCountOk = Math.min(this.computedAccuracy.n100, speedNoteCount - relevantCountMiss - relevantCountMeh);
+        const relevantCountGreat = Math.max(0, speedNoteCount -
+            relevantCountMiss -
+            relevantCountMeh -
+            relevantCountOk);
+        return this.calculateDeviation(relevantCountGreat, relevantCountOk, relevantCountMeh, relevantCountMiss);
+    }
+    /**
+     * Estimates the player's tap deviation based on the OD, given number of greats, oks, mehs and misses,
+     * assuming the player's mean hit error is 0. The estimation is consistent in that two SS scores on the
+     * same map with the same settings will always return the same deviation.
+     *
+     * Misses are ignored because they are usually due to misaiming.
+     *
+     * Greats and oks are assumed to follow a normal distribution, whereas mehs are assumed to follow a uniform distribution.
+     */
+    calculateDeviation(relevantCountGreat, relevantCountOk, relevantCountMeh, relevantCountMiss) {
+        if (relevantCountGreat + relevantCountOk + relevantCountMeh <= 0) {
+            return Number.POSITIVE_INFINITY;
+        }
+        const objectCount = relevantCountGreat +
+            relevantCountOk +
+            relevantCountMeh +
+            relevantCountMiss;
+        // Obtain the great, ok, and meh windows.
+        const hitWindow = new osuBase.OsuHitWindow(osuBase.OsuHitWindow.greatWindowToOD(
+        // Convert current OD to non clock rate-adjusted OD.
+        new osuBase.OsuHitWindow(this.difficultyAttributes.overallDifficulty)
+            .greatWindow * this.difficultyAttributes.clockRate));
+        const { greatWindow, okWindow, mehWindow } = hitWindow;
+        // The probability that a player hits a circle is unknown, but we can estimate it to be
+        // the number of greats on circles divided by the number of circles, and then add one
+        // to the number of circles as a bias correction.
+        const n = Math.max(1, objectCount - relevantCountMiss - relevantCountMeh);
+        // 99% critical value for the normal distribution (one-tailed).
+        const z = 2.32634787404;
+        // Proportion of greats hit on circles, ignoring misses and 50s.
+        const p = relevantCountGreat / n;
+        // We can be 99% confident that p is at least this value.
+        const pLowerBound = (n * p + (z * z) / 2) / (n + z * z) -
+            (z / (n + z * z)) * Math.sqrt(n * p * (1 - p) + (z * z) / 4);
+        // Compute the deviation assuming greats and oks are normally distributed, and mehs are uniformly distributed.
+        // Begin with greats and oks first. Ignoring mehs, we can be 99% confident that the deviation is not higher than:
+        let deviation = greatWindow / (Math.SQRT2 * osuBase.ErrorFunction.erfInv(pLowerBound));
+        const randomValue = (Math.sqrt(2 / Math.PI) *
+            okWindow *
+            Math.pow(Math.exp(-0.5 * (okWindow / deviation)), 2)) /
+            (deviation *
+                osuBase.ErrorFunction.erf(okWindow / (Math.SQRT2 * deviation)));
+        deviation *= Math.sqrt(1 - randomValue);
+        // Value deviation approach as greatCount approaches 0
+        const limitValue = okWindow / Math.sqrt(3);
+        // If precision is not enough to compute true deviation - use limit value
+        if (pLowerBound == 0.0 || randomValue >= 1 || deviation > limitValue) {
+            deviation = limitValue;
+        }
+        // Then compute the variance for mehs.
+        const mehVariance = (Math.pow(mehWindow, 2) +
+            okWindow * mehWindow +
+            Math.pow(okWindow, 2)) /
+            3;
+        // Find the total deviation.
+        deviation = Math.sqrt(((relevantCountGreat + relevantCountOk) * Math.pow(deviation, 2) +
+            relevantCountMeh * mehVariance) /
+            (relevantCountGreat + relevantCountOk + relevantCountMeh));
+        return deviation;
+    }
+    /**
+     * Calculates multiplier for speed to account for improper tapping based on the deviation and speed difficulty.
+     *
+     * [Graph](https://www.desmos.com/calculator/dmogdhzofn)
+     */
+    calculateSpeedHighDeviationNerf() {
+        if (this.speedDeviation == Number.POSITIVE_INFINITY) {
+            return 0;
+        }
+        const speedValue = this.baseValue(this.difficultyAttributes.speedDifficulty);
+        // Decide a point where the PP value achieved compared to the speed deviation is assumed to be tapped
+        // improperly. Any PP above this point is considered "excess" speed difficulty. This is used to cause
+        // PP above the cutoff to scale logarithmically towards the original speed value thus nerfing the value.
+        const excessSpeedDifficultyCutoff = 100 + 220 * Math.pow(22 / this.speedDeviation, 6.5);
+        if (speedValue <= excessSpeedDifficultyCutoff) {
+            return 1;
+        }
+        const scale = 50;
+        const adjustedSpeedValue = scale *
+            (Math.log((speedValue - excessSpeedDifficultyCutoff) / scale + 1) +
+                excessSpeedDifficultyCutoff / scale);
+        // 220 UR and less are considered tapped correctly to ensure that normal scores will be punished as little as possible
+        const t = 1 - osuBase.Interpolation.reverseLerp(this.speedDeviation, 22, 27);
+        return (osuBase.Interpolation.lerp(adjustedSpeedValue, speedValue, t) / speedValue);
+    }
     toString() {
         return (this.total.toFixed(2) +
             " pp (" +
@@ -3855,7 +4076,6 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
     }
 }
 
-exports.AimEvaluator = AimEvaluator;
 exports.DifficultyCalculator = DifficultyCalculator;
 exports.DifficultyHitObject = DifficultyHitObject;
 exports.DroidAim = DroidAim;
@@ -3871,7 +4091,6 @@ exports.DroidTap = DroidTap;
 exports.DroidTapEvaluator = DroidTapEvaluator;
 exports.DroidVisual = DroidVisual;
 exports.DroidVisualEvaluator = DroidVisualEvaluator;
-exports.FlashlightEvaluator = FlashlightEvaluator;
 exports.OsuAim = OsuAim;
 exports.OsuAimEvaluator = OsuAimEvaluator;
 exports.OsuDifficultyCalculator = OsuDifficultyCalculator;
@@ -3883,5 +4102,4 @@ exports.OsuRhythmEvaluator = OsuRhythmEvaluator;
 exports.OsuSpeed = OsuSpeed;
 exports.OsuSpeedEvaluator = OsuSpeedEvaluator;
 exports.PerformanceCalculator = PerformanceCalculator;
-exports.SpeedEvaluator = SpeedEvaluator;
 //# sourceMappingURL=index.js.map