@rian8337/osu-difficulty-calculator 4.0.0-beta.3 → 4.0.0-beta.31

package/dist/index.js

@@ -8,10 +8,6 @@ var osuBase = require('@rian8337/osu-base');
  * This class should be considered an "evaluating" class and not persisted.
  */
 class AimEvaluator {
-    static wideAngleMultiplier = 1.5;
-    static acuteAngleMultiplier = 1.95;
-    static sliderMultiplier = 1.35;
-    static velocityChangeMultiplier = 0.75;
     /**
      * Calculates the bonus of wide angles.
      */
@@ -27,154 +23,244 @@ class AimEvaluator {
         return 1 - this.calculateWideAngleBonus(angle);
     }
 }
+AimEvaluator.wideAngleMultiplier = 1.5;
+AimEvaluator.acuteAngleMultiplier = 1.95;
+AimEvaluator.sliderMultiplier = 1.35;
+AimEvaluator.velocityChangeMultiplier = 0.75;
 
 /**
- * Represents an osu!standard hit object with difficulty calculation values.
+ * The base of a difficulty calculator.
  */
-class DifficultyHitObject {
-    /**
-     * The underlying hitobject.
-     */
-    object;
-    /**
-     * The index of this hitobject in the list of all hitobjects.
-     *
-     * This is one less than the actual index of the hitobject in the beatmap.
-     */
-    index = 0;
-    /**
-     * The preempt time of the hitobject.
-     */
-    baseTimePreempt = 600;
-    /**
-     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
-     */
-    timePreempt = 600;
-    /**
-     * The fade in time of the hitobject.
-     */
-    timeFadeIn = 400;
-    /**
-     * The aim strain generated by the hitobject if sliders are considered.
-     */
-    aimStrainWithSliders = 0;
-    /**
-     * The aim strain generated by the hitobject if sliders are not considered.
-     */
-    aimStrainWithoutSliders = 0;
-    /**
-     * The tap strain generated by the hitobject.
-     *
-     * This is also used for osu!standard as opposed to "speed strain".
-     */
-    tapStrain = 0;
-    /**
-     * The tap strain generated by the hitobject if `strainTime` isn't modified by
-     * OD. This is used in three-finger detection.
-     */
-    originalTapStrain = 0;
-    /**
-     * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
-     */
-    rhythmMultiplier = 0;
-    /**
-     * The rhythm strain generated by the hitobject.
-     */
-    rhythmStrain = 0;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are considered.
-     */
-    flashlightStrainWithSliders = 0;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are not considered.
-     */
-    flashlightStrainWithoutSliders = 0;
+class DifficultyCalculator {
     /**
-     * The visual strain generated by the hitobject if sliders are considered.
+     * The difficulty objects of the beatmap.
      */
-    visualStrainWithSliders = 0;
+    get objects() {
+        return this._objects;
+    }
     /**
-     * The visual strain generated by the hitobject if sliders are not considered.
+     * The total star rating of the beatmap.
      */
-    visualStrainWithoutSliders = 0;
+    get total() {
+        return this.attributes.starRating;
+    }
     /**
-     * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
+     * Constructs a new instance of the calculator.
      *
-     * The "lazy" end position is the position at which the cursor ends up if the previous hitobject is followed with as minimal movement as possible (i.e. on the edge of slider follow circles).
+     * @param beatmap The beatmap to calculate.
      */
-    lazyJumpDistance = 0;
+    constructor(beatmap) {
+        /**
+         * The difficulty objects of the beatmap.
+         */
+        this._objects = [];
+        /**
+         * The modifications applied.
+         */
+        this.mods = [];
+        /**
+         * The strain peaks of various calculated difficulties.
+         */
+        this.strainPeaks = {
+            aimWithSliders: [],
+            aimWithoutSliders: [],
+            speed: [],
+            flashlight: [],
+        };
+        this.beatmap = beatmap;
+    }
     /**
-     * The normalized shortest distance to consider for a jump between the previous hitobject and this hitobject.
+     * Calculates the star rating of the specified beatmap.
      *
-     * This is bounded from above by `lazyJumpDistance`, and is smaller than the former if a more natural path is able to be taken through the previous hitobject.
+     * The beatmap is analyzed in chunks of `sectionLength` duration.
+     * For each chunk the highest hitobject strains are added to
+     * a list which is then collapsed into a weighted sum, much
+     * like scores are weighted on a user's profile.
      *
-     * Suppose a linear slider - circle pattern. Following the slider lazily (see: `lazyJumpDistance`) will result in underestimating the true end position of the slider as being closer towards the start position.
-     * As a result, `lazyJumpDistance` overestimates the jump distance because the player is able to take a more natural path by following through the slider to its end,
-     * such that the jump is felt as only starting from the slider's true end position.
+     * For subsequent chunks, the initial max strain is calculated
+     * by decaying the previous hitobject's strain until the
+     * beginning of the new chunk.
      *
-     * Now consider a slider - circle pattern where the circle is stacked along the path inside the slider.
-     * In this case, the lazy end position correctly estimates the true end position of the slider and provides the more natural movement path.
-     */
-    minimumJumpDistance = 0;
-    /**
-     * The time taken to travel through `minimumJumpDistance`, with a minimum value of 25ms.
-     */
-    minimumJumpTime = 0;
-    /**
-     * The normalized distance between the start and end position of this hitobject.
-     */
-    travelDistance = 0;
-    /**
-     * The time taken to travel through `travelDistance`, with a minimum value of 25ms for sliders.
+     * @param options Options for the difficulty calculation.
+     * @returns The current instance.
      */
-    travelTime = 0;
+    calculate(options) {
+        var _a;
+        this.mods = (_a = options === null || options === void 0 ? void 0 : options.mods) !== null && _a !== void 0 ? _a : [];
+        const playableBeatmap = this.beatmap.createPlayableBeatmap({
+            mode: this.mode,
+            mods: this.mods,
+            customSpeedMultiplier: options === null || options === void 0 ? void 0 : options.customSpeedMultiplier,
+        });
+        const clockRate = this.calculateClockRate(options);
+        this.populateDifficultyAttributes(playableBeatmap, clockRate);
+        this._objects = this.generateDifficultyHitObjects(playableBeatmap, clockRate);
+        this.calculateAll();
+        return this;
+    }
     /**
-     * Angle the player has to take to hit this hitobject.
+     * Calculates the skills provided.
      *
-     * Calculated as the angle between the circles (current-2, current-1, current).
-     */
-    angle = null;
-    /**
-     * The amount of milliseconds elapsed between this hitobject and the last hitobject.
-     */
-    deltaTime = 0;
-    /**
-     * The amount of milliseconds elapsed since the start time of the previous hitobject, with a minimum of 25ms.
-     */
-    strainTime = 0;
-    /**
-     * Adjusted start time of the hitobject, taking speed multiplier into account.
-     */
-    startTime = 0;
-    /**
-     * Adjusted end time of the hitobject, taking speed multiplier into account.
+     * @param skills The skills to calculate.
      */
-    endTime = 0;
+    calculateSkills(...skills) {
+        // The first object doesn't generate a strain, so we begin calculating from the second object.
+        for (const object of this.objects.slice(1)) {
+            for (const skill of skills) {
+                skill.process(object);
+            }
+        }
+    }
     /**
-     * The note density of the hitobject.
+     * Obtains the clock rate of the beatmap.
+     *
+     * @param options The options to obtain the clock rate with.
+     * @returns The clock rate of the beatmap.
      */
-    noteDensity = 1;
+    calculateClockRate(options) {
+        var _a, _b;
+        return (osuBase.ModUtil.calculateRateWithMods((_a = options === null || options === void 0 ? void 0 : options.mods) !== null && _a !== void 0 ? _a : []) *
+            ((_b = options === null || options === void 0 ? void 0 : options.customSpeedMultiplier) !== null && _b !== void 0 ? _b : 1));
+    }
     /**
-     * The overlapping factor of the hitobject.
+     * Populates the stored difficulty attributes with necessary data.
      *
-     * This is used to scale visual skill.
+     * @param beatmap The beatmap to populate the attributes with.
+     * @param clockRate The clock rate of the beatmap.
      */
-    overlappingFactor = 0;
+    populateDifficultyAttributes(beatmap, clockRate) {
+        this.attributes.hitCircleCount = this.beatmap.hitObjects.circles;
+        this.attributes.maxCombo = this.beatmap.maxCombo;
+        this.attributes.mods = this.mods.slice();
+        this.attributes.sliderCount = this.beatmap.hitObjects.sliders;
+        this.attributes.spinnerCount = this.beatmap.hitObjects.spinners;
+        this.attributes.clockRate = clockRate;
+        let greatWindow;
+        switch (this.mode) {
+            case osuBase.Modes.droid:
+                greatWindow = new osuBase.DroidHitWindow(beatmap.difficulty.od).hitWindowFor300(this.mods.some((m) => m instanceof osuBase.ModPrecise));
+                break;
+            case osuBase.Modes.osu:
+                greatWindow = new osuBase.OsuHitWindow(beatmap.difficulty.od).hitWindowFor300();
+                break;
+        }
+        this.attributes.overallDifficulty = osuBase.OsuHitWindow.hitWindow300ToOD(greatWindow / clockRate);
+    }
     /**
-     * Adjusted velocity of the hitobject, taking speed multiplier into account.
+     * Calculates the star rating value of a difficulty.
+     *
+     * @param difficulty The difficulty to calculate.
      */
-    velocity = 0;
+    starValue(difficulty) {
+        return Math.sqrt(difficulty) * this.difficultyMultiplier;
+    }
     /**
-     * Other hitobjects in the beatmap, including this hitobject.
+     * Calculates the base performance value of a difficulty rating.
+     *
+     * @param rating The difficulty rating.
      */
-    hitObjects;
+    basePerformanceValue(rating) {
+        return Math.pow(5 * Math.max(1, rating / 0.0675) - 4, 3) / 100000;
+    }
+}
+
+/**
+ * Represents a hit object with difficulty calculation values.
+ */
+class DifficultyHitObject {
     /**
+     * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
+     * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue).
+     *
      * @param object The underlying hitobject.
-     * @param hitObjects All difficulty hitobjects in the processed beatmap.
-     */
-    constructor(object, hitObjects) {
+     * @param lastObject The hitobject before this hitobject.
+     * @param lastLastObject The hitobject before the last hitobject.
+     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
+     * @param clockRate The clock rate of the beatmap.
+     * @param greatWindow The great window of the hitobject.
+     */
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, greatWindow) {
+        /**
+         * The aim strain generated by the hitobject if sliders are considered.
+         */
+        this.aimStrainWithSliders = 0;
+        /**
+         * The aim strain generated by the hitobject if sliders are not considered.
+         */
+        this.aimStrainWithoutSliders = 0;
+        /**
+         * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
+         */
+        this.rhythmMultiplier = 0;
+        /**
+         * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
+         *
+         * The "lazy" end position is the position at which the cursor ends up if the previous hitobject is followed with as minimal movement as possible (i.e. on the edge of slider follow circles).
+         */
+        this.lazyJumpDistance = 0;
+        /**
+         * The normalized shortest distance to consider for a jump between the previous hitobject and this hitobject.
+         *
+         * This is bounded from above by `lazyJumpDistance`, and is smaller than the former if a more natural path is able to be taken through the previous hitobject.
+         *
+         * Suppose a linear slider - circle pattern. Following the slider lazily (see: `lazyJumpDistance`) will result in underestimating the true end position of the slider as being closer towards the start position.
+         * As a result, `lazyJumpDistance` overestimates the jump distance because the player is able to take a more natural path by following through the slider to its end,
+         * such that the jump is felt as only starting from the slider's true end position.
+         *
+         * Now consider a slider - circle pattern where the circle is stacked along the path inside the slider.
+         * In this case, the lazy end position correctly estimates the true end position of the slider and provides the more natural movement path.
+         */
+        this.minimumJumpDistance = 0;
+        /**
+         * The time taken to travel through `minimumJumpDistance`, with a minimum value of 25ms.
+         */
+        this.minimumJumpTime = 0;
+        /**
+         * The normalized distance between the start and end position of this hitobject.
+         */
+        this.travelDistance = 0;
+        /**
+         * The time taken to travel through `travelDistance`, with a minimum value of 25ms for sliders.
+         */
+        this.travelTime = 0;
+        /**
+         * Angle the player has to take to hit this hitobject.
+         *
+         * Calculated as the angle between the circles (current-2, current-1, current).
+         */
+        this.angle = null;
+        this.normalizedRadius = 50;
+        this.maximumSliderRadius = this.normalizedRadius * 2.4;
+        this.assumedSliderRadius = this.normalizedRadius * 1.8;
         this.object = object;
-        this.hitObjects = hitObjects;
+        this.lastObject = lastObject;
+        this.lastLastObject = lastLastObject;
+        this.hitObjects = difficultyHitObjects;
+        this.fullGreatWindow = greatWindow * 2;
+        this.index = difficultyHitObjects.length - 1;
+        // Capped to 25ms to prevent difficulty calculation breaking from simultaneous objects.
+        this.startTime = object.startTime / clockRate;
+        this.endTime = object.endTime / clockRate;
+        if (lastObject) {
+            this.deltaTime = this.startTime - lastObject.startTime / clockRate;
+            this.strainTime = Math.max(this.deltaTime, DifficultyHitObject.minDeltaTime);
+        }
+        else {
+            this.deltaTime = 0;
+            this.strainTime = 0;
+        }
+    }
+    /**
+     * Computes the properties of this hitobject.
+     *
+     * @param clockRate The clock rate of the beatmap.
+     * @param hitObjects The hitobjects in the beatmap.
+     */
+    computeProperties(clockRate, 
+    // Required for `DroidDifficultyHitObject` override.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    hitObjects) {
+        this.setDistances(clockRate);
     }
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
@@ -187,7 +273,8 @@ class DifficultyHitObject {
      * difficulty hitobject's index, `null` if the index is out of range.
      */
     previous(backwardsIndex) {
-        return this.hitObjects[this.index - backwardsIndex] ?? null;
+        var _a;
+        return (_a = this.hitObjects[this.index - backwardsIndex]) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
@@ -200,285 +287,128 @@ class DifficultyHitObject {
      * difficulty hitobject's index, `null` if the index is out of range.
      */
     next(forwardsIndex) {
-        return this.hitObjects[this.index + forwardsIndex + 2] ?? null;
+        var _a;
+        return ((_a = this.hitObjects[this.index + forwardsIndex + 2]) !== null && _a !== void 0 ? _a : null);
     }
     /**
      * 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 mode The gamemode to calculate the opacity for.
      * @returns The opacity of the hitobject at the given time.
      */
-    opacityAt(time, isHidden, mode) {
+    opacityAt(time, isHidden) {
         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,
             // but this is an approximation and such a case is unlikely to be hit where this function is used.
             return 0;
         }
-        const fadeInStartTime = this.object.startTime - this.baseTimePreempt;
-        const fadeInDuration = this.timeFadeIn;
+        const fadeInStartTime = this.object.startTime - this.object.timePreempt;
+        const fadeInDuration = this.object.timeFadeIn;
         if (isHidden) {
             const fadeOutStartTime = fadeInStartTime + fadeInDuration;
-            const fadeOutDuration = this.baseTimePreempt *
-                (mode === osuBase.Modes.droid
-                    ? 0.35
-                    : osuBase.ModHidden.fadeOutDurationMultiplier);
+            const fadeOutDuration = this.object.timePreempt * osuBase.ModHidden.fadeOutDurationMultiplier;
             return Math.min(osuBase.MathUtils.clamp((time - fadeInStartTime) / fadeInDuration, 0, 1), 1 -
                 osuBase.MathUtils.clamp((time - fadeOutStartTime) / fadeOutDuration, 0, 1));
         }
         return osuBase.MathUtils.clamp((time - fadeInStartTime) / fadeInDuration, 0, 1);
     }
     /**
-     * Determines whether this hitobject is considered overlapping with the hitobject before it.
-     *
-     * Keep in mind that "overlapping" in this case is overlapping to the point where both hitobjects
-     * can be hit with just a single tap in osu!droid.
+     * How possible is it to doubletap this object together with the next one and get perfect
+     * judgement in range from 0 to 1.
      *
-     * @param considerDistance Whether to consider the distance between both hitobjects.
-     * @returns Whether the hitobject is considered overlapping.
+     * A value closer to 1 indicates a higher possibility.
      */
-    isOverlapping(considerDistance) {
-        if (this.object instanceof osuBase.Spinner) {
-            return false;
-        }
-        const previous = this.previous(0);
-        if (!previous || previous.object instanceof osuBase.Spinner) {
-            return false;
-        }
-        if (this.deltaTime >= 5) {
-            return false;
-        }
-        if (considerDistance) {
-            const endPosition = this.object.getStackedPosition(osuBase.Modes.droid);
-            let distance = previous.object
-                .getStackedEndPosition(osuBase.Modes.droid)
-                .getDistance(endPosition);
-            if (previous.object instanceof osuBase.Slider &&
-                previous.object.lazyEndPosition) {
-                distance = Math.min(distance, previous.object.lazyEndPosition.getDistance(endPosition));
-            }
-            return distance <= 2 * this.object.getRadius(osuBase.Modes.droid);
+    get doubletapness() {
+        const next = this.next(0);
+        if (!next) {
+            return 0;
         }
-        return true;
-    }
-}
-
-/**
- * A converter used to convert normal hitobjects into difficulty hitobjects.
- */
-class DifficultyHitObjectCreator {
-    /**
-     * The threshold for small circle buff for osu!droid.
-     */
-    DROID_CIRCLESIZE_BUFF_THRESHOLD = 70;
-    /**
-     * The threshold for small circle buff for osu!standard.
-     */
-    PC_CIRCLESIZE_BUFF_THRESHOLD = 30;
-    /**
-     * The gamemode this creator is creating for.
-     */
-    mode = osuBase.Modes.osu;
-    /**
-     * The base normalized radius of hitobjects.
-     */
-    normalizedRadius = 50;
-    maximumSliderRadius = this.normalizedRadius * 2.4;
-    assumedSliderRadius = this.normalizedRadius * 1.8;
-    minDeltaTime = 25;
-    /**
-     * Generates difficulty hitobjects for difficulty calculation.
-     */
-    generateDifficultyObjects(params) {
-        params.preempt ??= 600;
-        this.mode = params.mode;
-        if (this.mode === osuBase.Modes.droid) {
-            this.maximumSliderRadius = this.normalizedRadius * 2;
-        }
-        const droidCircleSize = new osuBase.MapStats({
-            cs: params.circleSize,
-            mods: params.mods,
-        }).calculate({ mode: osuBase.Modes.droid }).cs;
-        const droidScale = (1 - (0.7 * (droidCircleSize - 5)) / 5) / 2;
-        const osuCircleSize = new osuBase.MapStats({
-            cs: params.circleSize,
-            mods: params.mods,
-        }).calculate({ mode: osuBase.Modes.osu }).cs;
-        const osuScale = (1 - (0.7 * (osuCircleSize - 5)) / 5) / 2;
-        params.objects[0].droidScale = droidScale;
-        params.objects[0].osuScale = osuScale;
-        const scalingFactor = this.getScalingFactor(params.objects[0].getRadius(this.mode));
-        const difficultyObjects = [];
-        for (let i = 0; i < params.objects.length; ++i) {
-            const object = new DifficultyHitObject(params.objects[i], difficultyObjects);
-            object.index = difficultyObjects.length - 1;
-            object.object.droidScale = droidScale;
-            object.object.osuScale = osuScale;
-            object.timePreempt = params.preempt;
-            object.baseTimePreempt = params.preempt * params.speedMultiplier;
-            if (object.object instanceof osuBase.Slider) {
-                object.velocity =
-                    object.object.velocity * params.speedMultiplier;
-                object.object.nestedHitObjects.forEach((o) => {
-                    o.droidScale = droidScale;
-                    o.osuScale = osuScale;
-                });
-                this.calculateSliderCursorPosition(object.object);
-                object.travelDistance = object.object.lazyTravelDistance;
-                // Bonus for repeat sliders until a better per nested object strain system can be achieved.
-                if (this.mode === osuBase.Modes.droid) {
-                    object.travelDistance *= Math.pow(1 + object.object.repeats / 4, 1 / 4);
-                }
-                else {
-                    object.travelDistance *= Math.pow(1 + object.object.repeats / 2.5, 1 / 2.5);
-                }
-                object.travelTime = Math.max(object.object.lazyTravelTime / params.speedMultiplier, this.minDeltaTime);
+        const currentDeltaTime = Math.max(1, this.deltaTime);
+        const nextDeltaTime = Math.max(1, next.deltaTime);
+        const deltaDifference = Math.abs(nextDeltaTime - currentDeltaTime);
+        const speedRatio = currentDeltaTime / Math.max(currentDeltaTime, deltaDifference);
+        const windowRatio = Math.pow(Math.min(1, currentDeltaTime / this.fullGreatWindow), 2);
+        return 1 - Math.pow(speedRatio, 1 - windowRatio);
+    }
+    setDistances(clockRate) {
+        if (this.object instanceof osuBase.Slider) {
+            this.calculateSliderCursorPosition(this.object);
+            this.travelDistance = this.object.lazyTravelDistance;
+            // Bonus for repeat sliders until a better per nested object strain system can be achieved.
+            if (this.mode === osuBase.Modes.droid) {
+                this.travelDistance *= Math.pow(1 + this.object.repeatCount / 4, 1 / 4);
             }
-            const lastObject = difficultyObjects[i - 1];
-            const lastLastObject = difficultyObjects[i - 2];
-            object.startTime = object.object.startTime / params.speedMultiplier;
-            object.endTime = object.object.endTime / params.speedMultiplier;
-            if (!lastObject) {
-                difficultyObjects.push(object);
-                continue;
-            }
-            object.deltaTime =
-                (object.object.startTime - lastObject.object.startTime) /
-                    params.speedMultiplier;
-            // Cap to 25ms to prevent difficulty calculation breaking from simultaneous objects.
-            object.strainTime = Math.max(this.minDeltaTime, object.deltaTime);
-            if (object.object instanceof osuBase.Spinner) {
-                difficultyObjects.push(object);
-                continue;
-            }
-            // We'll have two visible object arrays. The first array contains objects before the current object starts in a reversed order,
-            // while the second array contains objects after the current object ends.
-            // For overlapping factor, we also need to consider previous visible objects.
-            const prevVisibleObjects = [];
-            const nextVisibleObjects = [];
-            for (let j = i + 1; j < params.objects.length; ++j) {
-                const o = params.objects[j];
-                if (o instanceof osuBase.Spinner) {
-                    continue;
-                }
-                if (o.startTime / params.speedMultiplier >
-                    object.endTime + object.timePreempt) {
-                    break;
-                }
-                // Future objects do not have their scales set, so we set them here.
-                o.droidScale = droidScale;
-                o.osuScale = osuScale;
-                nextVisibleObjects.push(o);
-            }
-            for (let j = 0; j < object.index; ++j) {
-                const prev = object.previous(j);
-                if (prev.object instanceof osuBase.Spinner) {
-                    continue;
-                }
-                if (prev.startTime >= object.startTime) {
-                    continue;
-                }
-                if (prev.startTime < object.startTime - object.timePreempt) {
-                    break;
-                }
-                prevVisibleObjects.push(prev.object);
-            }
-            for (const hitObject of prevVisibleObjects) {
-                const distance = object.object
-                    .getStackedPosition(this.mode)
-                    .getDistance(hitObject.getStackedEndPosition(this.mode));
-                const deltaTime = object.startTime -
-                    hitObject.endTime / params.speedMultiplier;
-                this.applyToOverlappingFactor(object, distance, deltaTime);
-            }
-            for (const hitObject of nextVisibleObjects) {
-                const distance = hitObject
-                    .getStackedPosition(this.mode)
-                    .getDistance(object.object.getStackedEndPosition(this.mode));
-                const deltaTime = hitObject.startTime / params.speedMultiplier -
-                    object.endTime;
-                if (deltaTime >= 0) {
-                    object.noteDensity += 1 - deltaTime / object.timePreempt;
-                }
-                this.applyToOverlappingFactor(object, distance, deltaTime);
-            }
-            if (lastObject.object instanceof osuBase.Spinner) {
-                difficultyObjects.push(object);
-                continue;
+            else {
+                this.travelDistance *= Math.pow(1 + this.object.repeatCount / 2.5, 1 / 2.5);
             }
-            const lastCursorPosition = this.getEndCursorPosition(lastObject.object);
-            object.lazyJumpDistance = object.object
+            this.travelTime = Math.max(this.object.lazyTravelTime / clockRate, DifficultyHitObject.minDeltaTime);
+        }
+        // We don't need to calculate either angle or distance when one of the last->curr objects is a spinner.
+        if (!this.lastObject ||
+            this.object instanceof osuBase.Spinner ||
+            this.lastObject instanceof osuBase.Spinner) {
+            return;
+        }
+        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
+        const { scalingFactor } = this;
+        const lastCursorPosition = this.getEndCursorPosition(this.lastObject);
+        this.lazyJumpDistance = this.object
+            .getStackedPosition(this.mode)
+            .scale(scalingFactor)
+            .subtract(lastCursorPosition.scale(scalingFactor)).length;
+        this.minimumJumpTime = this.strainTime;
+        this.minimumJumpDistance = this.lazyJumpDistance;
+        if (this.lastObject instanceof osuBase.Slider) {
+            const lastTravelTime = Math.max(this.lastObject.lazyTravelTime / clockRate, DifficultyHitObject.minDeltaTime);
+            this.minimumJumpTime = Math.max(this.strainTime - lastTravelTime, DifficultyHitObject.minDeltaTime);
+            // There are two types of slider-to-object patterns to consider in order to better approximate the real movement a player will take to jump between the hitobjects.
+            //
+            // 1. The anti-flow pattern, where players cut the slider short in order to move to the next hitobject.
+            //
+            //      <======o==>  ← slider
+            //             |     ← most natural jump path
+            //             o     ← a follow-up hitcircle
+            //
+            // In this case the most natural jump path is approximated by LazyJumpDistance.
+            //
+            // 2. The flow pattern, where players follow through the slider to its visual extent into the next hitobject.
+            //
+            //      <======o==>---o
+            //                  ↑
+            //        most natural jump path
+            //
+            // In this case the most natural jump path is better approximated by a new distance called "tailJumpDistance" - the distance between the slider's tail and the next hitobject.
+            //
+            // Thus, the player is assumed to jump the minimum of these two distances in all cases.
+            const tailJumpDistance = this.lastObject.tail
                 .getStackedPosition(this.mode)
-                .scale(scalingFactor)
-                .subtract(lastCursorPosition.scale(scalingFactor)).length;
-            object.minimumJumpTime = object.strainTime;
-            object.minimumJumpDistance = object.lazyJumpDistance;
-            if (lastObject.object instanceof osuBase.Slider) {
-                object.minimumJumpTime = Math.max(object.strainTime - lastObject.travelTime, this.minDeltaTime);
-                // There are two types of slider-to-object patterns to consider in order to better approximate the real movement a player will take to jump between the hitobjects.
-                //
-                // 1. The anti-flow pattern, where players cut the slider short in order to move to the next hitobject.
-                //
-                //      <======o==>  ← slider
-                //             |     ← most natural jump path
-                //             o     ← a follow-up hitcircle
-                //
-                // In this case the most natural jump path is approximated by LazyJumpDistance.
-                //
-                // 2. The flow pattern, where players follow through the slider to its visual extent into the next hitobject.
-                //
-                //      <======o==>---o
-                //                  ↑
-                //        most natural jump path
-                //
-                // In this case the most natural jump path is better approximated by a new distance called "tailJumpDistance" - the distance between the slider's tail and the next hitobject.
-                //
-                // Thus, the player is assumed to jump the minimum of these two distances in all cases.
-                const tailJumpDistance = lastObject.object.tail
-                    .getStackedPosition(this.mode)
-                    .subtract(object.object.getStackedPosition(this.mode))
-                    .length * scalingFactor;
-                object.minimumJumpDistance = Math.max(0, Math.min(object.lazyJumpDistance -
-                    (this.maximumSliderRadius -
-                        this.assumedSliderRadius), tailJumpDistance - this.maximumSliderRadius));
-            }
-            if (lastLastObject && !(lastLastObject.object instanceof osuBase.Spinner)) {
-                const lastLastCursorPosition = this.getEndCursorPosition(lastLastObject.object);
-                const v1 = lastLastCursorPosition.subtract(lastObject.object.getStackedPosition(this.mode));
-                const v2 = object.object
-                    .getStackedPosition(this.mode)
-                    .subtract(lastCursorPosition);
-                const dot = v1.dot(v2);
-                const det = v1.x * v2.y - v1.y * v2.x;
-                object.angle = Math.abs(Math.atan2(det, dot));
-            }
-            difficultyObjects.push(object);
+                .subtract(this.object.getStackedPosition(this.mode))
+                .length * scalingFactor;
+            this.minimumJumpDistance = Math.max(0, Math.min(this.lazyJumpDistance -
+                (this.maximumSliderRadius - this.assumedSliderRadius), tailJumpDistance - this.maximumSliderRadius));
+        }
+        if (this.lastLastObject && !(this.lastLastObject instanceof osuBase.Spinner)) {
+            const lastLastCursorPosition = this.getEndCursorPosition(this.lastLastObject);
+            const v1 = lastLastCursorPosition.subtract(this.lastObject.getStackedPosition(this.mode));
+            const v2 = this.object
+                .getStackedPosition(this.mode)
+                .subtract(lastCursorPosition);
+            const dot = v1.dot(v2);
+            const det = v1.x * v2.y - v1.y * v2.x;
+            this.angle = Math.abs(Math.atan2(det, dot));
         }
-        return difficultyObjects;
     }
-    /**
-     * Calculates a slider's cursor position.
-     */
     calculateSliderCursorPosition(slider) {
         if (slider.lazyEndPosition) {
             return;
         }
-        // Droid doesn't have a legacy slider tail. Since beatmap parser defaults slider tail
-        // to legacy slider tail, it needs to be changed to real slider tail first.
         if (this.mode === osuBase.Modes.droid) {
-            slider.tail.startTime += osuBase.Slider.legacyLastTickOffset;
-            slider.tail.endTime += osuBase.Slider.legacyLastTickOffset;
-            slider.nestedHitObjects.sort((a, b) => a.startTime - b.startTime);
             // Temporary lazy end position until a real result can be derived.
             slider.lazyEndPosition = slider.getStackedPosition(this.mode);
-            // Stop here if the slider has too short duration due to float number limitation.
-            // Incredibly close start and end time fluctuates travel distance and lazy
-            // end position heavily, which we do not want to happen.
-            //
-            // In the real game, this shouldn't happen. Perhaps we need to reinvestigate this
-            // in the future.
+            // Stop here if the slider has too short duration, allowing the player to essentially
+            // complete the slider without movement, making travel distance and time irrelevant.
             if (osuBase.Precision.almostEqualsNumber(slider.startTime, slider.endTime)) {
                 return;
             }
@@ -498,7 +428,7 @@ class DifficultyHitObjectCreator {
             .getStackedPosition(this.mode)
             .add(slider.path.positionAt(endTimeMin));
         let currentCursorPosition = slider.getStackedPosition(this.mode);
-        const scalingFactor = this.normalizedRadius / slider.getRadius(this.mode);
+        const scalingFactor = this.normalizedRadius / slider.radius;
         for (let i = 1; i < slider.nestedHitObjects.length; ++i) {
             const currentMovementObject = slider.nestedHitObjects[i];
             let currentMovement = currentMovementObject
@@ -524,216 +454,38 @@ class DifficultyHitObjectCreator {
             }
             if (currentMovementLength > requiredMovement) {
                 // This finds the positional delta from the required radius and the current position,
-                // and updates the currentCursorPosition accordingly, as well as rewarding distance.
-                currentCursorPosition = currentCursorPosition.add(currentMovement.scale((currentMovementLength - requiredMovement) /
-                    currentMovementLength));
-                currentMovementLength *=
-                    (currentMovementLength - requiredMovement) /
-                        currentMovementLength;
-                slider.lazyTravelDistance += currentMovementLength;
-            }
-            if (i === slider.nestedHitObjects.length - 1) {
-                slider.lazyEndPosition = currentCursorPosition;
-            }
-        }
-    }
-    /**
-     * Gets the scaling factor of a radius.
-     *
-     * @param radius The radius to get the scaling factor from.
-     */
-    getScalingFactor(radius) {
-        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
-        let scalingFactor = this.normalizedRadius / radius;
-        // High circle size (small CS) bonus
-        switch (this.mode) {
-            case osuBase.Modes.droid:
-                if (radius < this.DROID_CIRCLESIZE_BUFF_THRESHOLD) {
-                    scalingFactor *=
-                        1 +
-                            Math.pow((this.DROID_CIRCLESIZE_BUFF_THRESHOLD - radius) /
-                                50, 2);
-                }
-                break;
-            case osuBase.Modes.osu:
-                if (radius < this.PC_CIRCLESIZE_BUFF_THRESHOLD) {
-                    scalingFactor *=
-                        1 +
-                            Math.min(this.PC_CIRCLESIZE_BUFF_THRESHOLD - radius, 5) /
-                                50;
-                }
-        }
-        return scalingFactor;
-    }
-    /**
-     * Returns the end cursor position of a hitobject.
-     */
-    getEndCursorPosition(object) {
-        let pos = object.getStackedPosition(this.mode);
-        if (object instanceof osuBase.Slider) {
-            this.calculateSliderCursorPosition(object);
-            pos = object.lazyEndPosition ?? pos;
-        }
-        return pos;
-    }
-    applyToOverlappingFactor(object, distance, deltaTime) {
-        // Penalize objects that are too close to the object in both distance
-        // and delta time to prevent stream maps from being overweighted.
-        object.overlappingFactor +=
-            Math.max(0, 1 - distance / (3 * object.object.getRadius(this.mode))) *
-                (7.5 /
-                    (1 +
-                        Math.exp(0.15 * (Math.max(deltaTime, this.minDeltaTime) - 75))));
-    }
-}
-
-/**
- * The base of difficulty calculators.
- */
-class DifficultyCalculator {
-    /**
-     * The calculated beatmap.
-     */
-    beatmap;
-    /**
-     * The difficulty objects of the beatmap.
-     */
-    objects = [];
-    /**
-     * The modifications applied.
-     */
-    mods = [];
-    /**
-     * The total star rating of the beatmap.
-     */
-    total = 0;
-    /**
-     * The map statistics of the beatmap after modifications are applied.
-     */
-    stats = new osuBase.MapStats();
-    /**
-     * The strain peaks of various calculated difficulties.
-     */
-    strainPeaks = {
-        aimWithSliders: [],
-        aimWithoutSliders: [],
-        speed: [],
-        flashlight: [],
-    };
-    sectionLength = 400;
-    /**
-     * Constructs a new instance of the calculator.
-     *
-     * @param beatmap The beatmap to calculate. This beatmap will be deep-cloned to prevent reference changes.
-     */
-    constructor(beatmap) {
-        this.beatmap = osuBase.Utils.deepCopy(beatmap);
-    }
-    /**
-     * Calculates the star rating of the specified beatmap.
-     *
-     * The beatmap is analyzed in chunks of `sectionLength` duration.
-     * For each chunk the highest hitobject strains are added to
-     * a list which is then collapsed into a weighted sum, much
-     * like scores are weighted on a user's profile.
-     *
-     * For subsequent chunks, the initial max strain is calculated
-     * by decaying the previous hitobject's strain until the
-     * beginning of the new chunk.
-     *
-     * @param options Options for the difficulty calculation.
-     * @returns The current instance.
-     */
-    calculate(options) {
-        this.mods = options?.mods ?? [];
-        this.stats = new osuBase.MapStats({
-            cs: this.beatmap.difficulty.cs,
-            ar: this.beatmap.difficulty.ar,
-            od: this.beatmap.difficulty.od,
-            hp: this.beatmap.difficulty.hp,
-            mods: options?.mods,
-            speedMultiplier: options?.stats?.speedMultiplier,
-            oldStatistics: options?.stats?.oldStatistics,
-        }).calculate({ mode: this.mode });
-        this.populateDifficultyAttributes();
-        this.generateDifficultyHitObjects();
-        this.calculateAll();
-        return this;
-    }
-    /**
-     * Generates difficulty hitobjects for this calculator.
-     */
-    generateDifficultyHitObjects() {
-        this.objects.length = 0;
-        this.objects.push(...new DifficultyHitObjectCreator().generateDifficultyObjects({
-            objects: this.beatmap.hitObjects.objects,
-            circleSize: this.beatmap.difficulty.cs,
-            mods: this.mods,
-            speedMultiplier: this.stats.speedMultiplier,
-            mode: this.mode,
-            preempt: osuBase.MapStats.arToMS(this.stats.ar),
-        }));
-    }
-    /**
-     * Calculates the skills provided.
-     *
-     * @param skills The skills to calculate.
-     */
-    calculateSkills(...skills) {
-        // The first object doesn't generate a strain, so we begin calculating from the second object.
-        this.objects.slice(1).forEach((h, i) => {
-            skills.forEach((skill) => {
-                skill.process(h);
-                if (i === this.objects.length - 2) {
-                    // Don't forget to save the last strain peak, which would otherwise be ignored.
-                    skill.saveCurrentPeak();
-                }
-            });
-        });
-    }
-    /**
-     * Populates the stored difficulty attributes with necessary data.
-     */
-    populateDifficultyAttributes() {
-        this.attributes.approachRate = this.stats.ar;
-        this.attributes.hitCircleCount = this.beatmap.hitObjects.circles;
-        this.attributes.maxCombo = this.beatmap.maxCombo;
-        this.attributes.mods = this.mods.slice();
-        this.attributes.overallDifficulty = this.stats.od;
-        this.attributes.sliderCount = this.beatmap.hitObjects.sliders;
-        this.attributes.spinnerCount = this.beatmap.hitObjects.spinners;
-    }
-    /**
-     * Calculates the star rating value of a difficulty.
-     *
-     * @param difficulty The difficulty to calculate.
-     */
-    starValue(difficulty) {
-        return Math.sqrt(difficulty) * this.difficultyMultiplier;
+                // and updates the currentCursorPosition accordingly, as well as rewarding distance.
+                currentCursorPosition = currentCursorPosition.add(currentMovement.scale((currentMovementLength - requiredMovement) /
+                    currentMovementLength));
+                currentMovementLength *=
+                    (currentMovementLength - requiredMovement) /
+                        currentMovementLength;
+                slider.lazyTravelDistance += currentMovementLength;
+            }
+            if (i === slider.nestedHitObjects.length - 1) {
+                slider.lazyEndPosition = currentCursorPosition;
+            }
+        }
     }
-    /**
-     * Calculates the base performance value of a difficulty rating.
-     *
-     * @param rating The difficulty rating.
-     */
-    basePerformanceValue(rating) {
-        return Math.pow(5 * Math.max(1, rating / 0.0675) - 4, 3) / 100000;
+    getEndCursorPosition(object) {
+        var _a;
+        let pos = object.getStackedPosition(this.mode);
+        if (object instanceof osuBase.Slider) {
+            this.calculateSliderCursorPosition(object);
+            pos = (_a = object.lazyEndPosition) !== null && _a !== void 0 ? _a : pos;
+        }
+        return pos;
     }
 }
+/**
+ * The lowest possible delta time value.
+ */
+DifficultyHitObject.minDeltaTime = 25;
 
 /**
  * An evaluator for calculating osu!droid Aim skill.
  */
 class DroidAimEvaluator extends AimEvaluator {
-    static wideAngleMultiplier = 1.65;
-    static sliderMultiplier = 1.5;
-    static velocityChangeMultiplier = 0.85;
-    /**
-     * Spacing threshold for a single hitobject spacing.
-     */
-    static SINGLE_SPACING_THRESHOLD = 175;
-    // ~200 1/2 BPM jumps
-    static minSpeedBonus = 150;
     /**
      * Evaluates the difficulty of aiming the current object, based on:
      *
@@ -751,15 +503,16 @@ class DroidAimEvaluator extends AimEvaluator {
             current.isOverlapping(true)) {
             return 0;
         }
-        return (this.aimStrainOf(current, withSliders) +
-            this.movementStrainOf(current));
+        return (this.snapAimStrainOf(current, withSliders) +
+            this.flowAimStrainOf(current));
     }
     /**
-     * Calculates the aim strain of a hitobject.
+     * Calculates the snap aim strain of a hitobject.
      */
-    static aimStrainOf(current, withSliders) {
+    static snapAimStrainOf(current, withSliders) {
+        var _a;
         if (current.index <= 1 ||
-            current.previous(0)?.object instanceof osuBase.Spinner) {
+            ((_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.object) instanceof osuBase.Spinner) {
             return 0;
         }
         const last = current.previous(0);
@@ -861,28 +614,33 @@ class DroidAimEvaluator extends AimEvaluator {
             velocityChangeBonus * this.velocityChangeMultiplier);
         // Add in additional slider velocity bonus.
         if (withSliders) {
-            strain += sliderBonus * this.sliderMultiplier;
+            strain +=
+                Math.pow(1 + sliderBonus * this.sliderMultiplier, 1.25) - 1;
         }
         return strain;
     }
     /**
-     * Calculates the movement strain of a hitobject.
+     * Calculates the flow aim strain of a hitobject.
      */
-    static movementStrainOf(current) {
+    static flowAimStrainOf(current) {
+        var _a, _b;
         let speedBonus = 1;
         if (current.strainTime < this.minSpeedBonus) {
             speedBonus +=
                 0.75 *
-                    Math.pow((this.minSpeedBonus - current.strainTime) / 45, 2);
+                    Math.pow((this.minSpeedBonus - current.strainTime) / 40, 2);
         }
-        const travelDistance = current.previous(0)?.travelDistance ?? 0;
-        const distance = Math.min(this.SINGLE_SPACING_THRESHOLD, travelDistance + current.minimumJumpDistance);
-        return ((50 *
-            speedBonus *
-            Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 5)) /
-            current.strainTime);
+        const travelDistance = (_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.travelDistance) !== null && _b !== void 0 ? _b : 0;
+        const shortDistancePenalty = Math.pow(Math.min(this.singleSpacingThreshold, travelDistance + current.minimumJumpDistance) / this.singleSpacingThreshold, 3.5);
+        return (200 * speedBonus * shortDistancePenalty) / current.strainTime;
     }
 }
+DroidAimEvaluator.wideAngleMultiplier = 1.65;
+DroidAimEvaluator.sliderMultiplier = 1.5;
+DroidAimEvaluator.velocityChangeMultiplier = 0.85;
+DroidAimEvaluator.singleSpacingThreshold = 100;
+// 200 1/4 BPM delta time
+DroidAimEvaluator.minSpeedBonus = 75;
 
 /**
  * A bare minimal abstract skill for fully custom skill implementations.
@@ -890,10 +648,6 @@ class DroidAimEvaluator extends AimEvaluator {
  * This class should be considered a "processing" class and not persisted.
  */
 class Skill {
-    /**
-     * The mods that this skill processes.
-     */
-    mods;
     constructor(mods) {
         this.mods = mods;
     }
@@ -904,33 +658,29 @@ class Skill {
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
  */
 class StrainSkill extends Skill {
+    constructor() {
+        super(...arguments);
+        /**
+         * Strain peaks are stored here.
+         */
+        this.strainPeaks = [];
+        this._objectStrains = [];
+        this.difficulty = 0;
+        this.sectionLength = 400;
+        this.currentStrain = 0;
+        this.currentSectionPeak = 0;
+        this.currentSectionEnd = 0;
+    }
     /**
-     * The strain of currently calculated hitobject.
-     */
-    currentStrain = 0;
-    /**
-     * The current section's strain peak.
-     */
-    currentSectionPeak = 0;
-    /**
-     * Strain peaks are stored here.
-     */
-    strainPeaks = [];
-    sectionLength = 400;
-    currentSectionEnd = 0;
-    isFirstObject = true;
-    /**
-     * Calculates the strain value of a hitobject and stores the value in it. This value is affected by previously processed objects.
-     *
-     * @param current The hitobject to process.
+     * The strains of hitobjects.
      */
+    get objectStrains() {
+        return this._objectStrains;
+    }
     process(current) {
         // The first object doesn't generate a strain, so we begin with an incremented section end
-        if (this.isFirstObject) {
-            this.currentSectionEnd =
-                Math.ceil(current.startTime / this.sectionLength) *
-                    this.sectionLength;
-            this.isFirstObject = false;
+        if (current.index === 0) {
+            this.currentSectionEnd = this.calculateCurrentSectionStart(current);
         }
         while (current.startTime > this.currentSectionEnd) {
             this.saveCurrentPeak();
@@ -941,6 +691,10 @@ class StrainSkill extends Skill {
         this.currentStrain = this.strainValueAt(current);
         this.saveToHitObject(current);
         this.currentSectionPeak = Math.max(this.currentStrain, this.currentSectionPeak);
+        if (!current.next(0)) {
+            // Don't forget to save the last strain peak, which would otherwise be ignored.
+            this.saveCurrentPeak();
+        }
     }
     /**
      * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
@@ -948,6 +702,21 @@ class StrainSkill extends Skill {
     saveCurrentPeak() {
         this.strainPeaks.push(this.currentSectionPeak);
     }
+    /**
+     * Returns the number of strains weighed against the top strain.
+     *
+     * The result is scaled by clock rate as it affects the total number of strains.
+     */
+    countDifficultStrains() {
+        if (this.difficulty === 0) {
+            return 0;
+        }
+        // This is what the top strain is if all strain values were identical.
+        const consistentTopStrain = this.difficulty / 10;
+        // Use a weighted sum of all strains.
+        return this._objectStrains.reduce((total, next) => total +
+            1.1 / (1 + Math.exp(-10 * (next / consistentTopStrain - 0.88))), 0);
+    }
     /**
      * Calculates strain decay for a specified time frame.
      *
@@ -956,18 +725,26 @@ class StrainSkill extends Skill {
     strainDecay(ms) {
         return Math.pow(this.strainDecayBase, ms / 1000);
     }
+    /**
+     * Calculates the starting time of a strain section at an object.
+     *
+     * @param current The object at which the strain section starts.
+     * @returns The start time of the strain section.
+     */
+    calculateCurrentSectionStart(current) {
+        return (Math.ceil(current.startTime / this.sectionLength) *
+            this.sectionLength);
+    }
     /**
      * Sets the initial strain level for a new section.
      *
-     * @param offset The beginning of the new section in milliseconds, adjusted by speed multiplier.
+     * @param time The beginning of the new section in milliseconds.
      * @param current The current hitobject.
      */
-    startNewSectionFrom(offset, current) {
-        // The maximum strain of the new section is not zero by default, strain decays as usual regardless of section boundaries.
+    startNewSectionFrom(time, current) {
+        // The maximum strain of the new section is not zero by default.
         // This means we need to capture the strain level at the beginning of the new section, and use that as the initial peak level.
-        this.currentSectionPeak =
-            this.currentStrain *
-                this.strainDecay(offset - current.previous(0).startTime);
+        this.currentSectionPeak = this.calculateInitialStrain(time, current);
     }
 }
 
@@ -976,6 +753,10 @@ class StrainSkill extends Skill {
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
  */
 class DroidSkill extends StrainSkill {
+    process(current) {
+        super.process(current);
+        this._objectStrains.push(this.getObjectStrain(current));
+    }
     difficultyValue() {
         const strains = this.strainPeaks.slice();
         if (this.reducedSectionCount > 0) {
@@ -988,12 +769,15 @@ class DroidSkill extends StrainSkill {
         }
         // Math here preserves the property that two notes of equal difficulty x, we have their summed difficulty = x * starsPerDouble.
         // This also applies to two sets of notes with equal difficulty.
-        return Math.pow(strains.reduce((a, v) => {
-            if (v <= 0) {
-                return a;
-            }
-            return a + Math.pow(v, 1 / Math.log2(this.starsPerDouble));
-        }, 0), Math.log2(this.starsPerDouble));
+        this.difficulty = 0;
+        for (const strain of strains) {
+            this.difficulty += Math.pow(strain, 1 / Math.log2(this.starsPerDouble));
+        }
+        this.difficulty = Math.pow(this.difficulty, Math.log2(this.starsPerDouble));
+        return this.difficulty;
+    }
+    calculateCurrentSectionStart(current) {
+        return current.startTime;
     }
 }
 
@@ -1001,35 +785,40 @@ class DroidSkill extends StrainSkill {
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 class DroidAim extends DroidSkill {
-    skillMultiplier = 24.55;
-    strainDecayBase = 0.15;
-    reducedSectionCount = 10;
-    reducedSectionBaseline = 0.75;
-    starsPerDouble = 1.05;
-    withSliders;
     constructor(mods, withSliders) {
         super(mods);
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.starsPerDouble = 1.05;
+        this.skillMultiplier = 24.55;
+        this.currentAimStrain = 0;
         this.withSliders = withSliders;
     }
-    /**
-     * @param current The hitobject to calculate.
-     */
     strainValueAt(current) {
-        this.currentStrain *= this.strainDecay(current.deltaTime);
-        this.currentStrain +=
+        this.currentAimStrain *= this.strainDecay(current.deltaTime);
+        this.currentAimStrain +=
             DroidAimEvaluator.evaluateDifficultyOf(current, this.withSliders) *
                 this.skillMultiplier;
-        return this.currentStrain;
+        return this.currentAimStrain;
+    }
+    calculateInitialStrain(time, current) {
+        var _a, _b;
+        return (this.currentAimStrain *
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
+    }
+    getObjectStrain() {
+        return this.currentAimStrain;
     }
     /**
      * @param current The hitobject to save to.
      */
     saveToHitObject(current) {
         if (this.withSliders) {
-            current.aimStrainWithSliders = this.currentStrain;
+            current.aimStrainWithSliders = this.currentAimStrain;
         }
         else {
-            current.aimStrainWithoutSliders = this.currentStrain;
+            current.aimStrainWithoutSliders = this.currentAimStrain;
         }
     }
 }
@@ -1040,9 +829,9 @@ class DroidAim extends DroidSkill {
  * This class should be considered an "evaluating" class and not persisted.
  */
 class SpeedEvaluator {
-    // ~200 1/4 BPM streams
-    static minSpeedBonus = 75;
 }
+// ~200 1/4 BPM streams
+SpeedEvaluator.minSpeedBonus = 75;
 
 /**
  * An evaluator for calculating osu!droid tap skill.
@@ -1053,43 +842,35 @@ class DroidTapEvaluator extends SpeedEvaluator {
      *
      * - time between pressing the previous and current object,
      * - distance between those objects,
-     * - and how easily they can be cheesed.
+     * - how easily they can be cheesed,
+     * - and the strain time cap.
      *
      * @param current The current object.
      * @param greatWindow The great hit window of the current object.
      * @param considerCheesability Whether to consider cheesability.
+     * @param strainTimeCap The strain time to cap the object's strain time to.
      */
-    static evaluateDifficultyOf(current, greatWindow, considerCheesability) {
+    static evaluateDifficultyOf(current, considerCheesability, strainTimeCap) {
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
             current.isOverlapping(false)) {
             return 0;
         }
-        let strainTime = current.strainTime;
-        let doubletapness = 1;
-        if (considerCheesability) {
-            const greatWindowFull = greatWindow * 2;
-            // Nerf doubletappable doubles.
-            const next = current.next(0);
-            if (next) {
-                const currentDeltaTime = Math.max(1, current.deltaTime);
-                const nextDeltaTime = Math.max(1, next.deltaTime);
-                const deltaDifference = Math.abs(nextDeltaTime - currentDeltaTime);
-                const speedRatio = currentDeltaTime /
-                    Math.max(currentDeltaTime, deltaDifference);
-                const windowRatio = Math.pow(Math.min(1, currentDeltaTime / greatWindowFull), 2);
-                doubletapness = Math.pow(speedRatio, 1 - windowRatio);
-            }
-            // Cap deltatime to the OD 300 hitwindow.
-            // 0.58 is derived from making sure 260 BPM 1/4 OD5 streams aren't nerfed harshly, whilst 0.91 limits the effect of the cap.
-            strainTime /= osuBase.MathUtils.clamp(strainTime / greatWindowFull / 0.58, 0.91, 1);
-        }
+        // Nerf doubletappable doubles.
+        const doubletapness = considerCheesability
+            ? 1 - current.doubletapness
+            : 1;
+        const strainTime = strainTimeCap !== undefined
+            ? // We cap the strain time to 50 here as the chance of vibro is higher in any BPM higher than 300.
+                Math.max(50, strainTimeCap, current.strainTime)
+            : current.strainTime;
         let speedBonus = 1;
         if (strainTime < this.minSpeedBonus) {
             speedBonus +=
-                0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
+                0.75 *
+                    Math.pow(osuBase.ErrorFunction.erf((this.minSpeedBonus - strainTime) / 40), 2);
         }
-        return (speedBonus * doubletapness) / strainTime;
+        return (speedBonus * Math.pow(doubletapness, 1.5)) / strainTime;
     }
 }
 
@@ -1097,38 +878,88 @@ class DroidTapEvaluator extends SpeedEvaluator {
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 class DroidTap extends DroidSkill {
-    skillMultiplier = 1375;
-    reducedSectionCount = 10;
-    reducedSectionBaseline = 0.75;
-    strainDecayBase = 0.3;
-    starsPerDouble = 1.1;
-    currentTapStrain = 0;
-    currentOriginalTapStrain = 0;
-    greatWindow;
-    constructor(mods, overallDifficulty) {
+    /**
+     * The delta time of hitobjects.
+     */
+    get objectDeltaTimes() {
+        return this._objectDeltaTimes;
+    }
+    constructor(mods, considerCheesability, strainTimeCap) {
         super(mods);
-        this.greatWindow = new osuBase.OsuHitWindow(overallDifficulty).hitWindowFor300();
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.strainDecayBase = 0.3;
+        this.starsPerDouble = 1.1;
+        this.currentTapStrain = 0;
+        this.currentRhythmMultiplier = 0;
+        this.skillMultiplier = 1375;
+        this._objectDeltaTimes = [];
+        this.considerCheesability = considerCheesability;
+        this.strainTimeCap = strainTimeCap;
+    }
+    /**
+     * The amount of notes that are relevant to the difficulty.
+     */
+    relevantNoteCount() {
+        if (this._objectStrains.length === 0) {
+            return 0;
+        }
+        const maxStrain = Math.max(...this._objectStrains);
+        if (maxStrain === 0) {
+            return 0;
+        }
+        return this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
     }
     /**
-     * @param current The hitobject to calculate.
+     * The delta time relevant to the difficulty.
      */
+    relevantDeltaTime() {
+        if (this._objectStrains.length === 0) {
+            return 0;
+        }
+        const maxStrain = Math.max(...this._objectStrains);
+        if (maxStrain === 0) {
+            return 0;
+        }
+        return (this._objectDeltaTimes.reduce((total, next, index) => total +
+            (next * 1) /
+                (1 +
+                    Math.exp(-((this._objectStrains[index] / maxStrain) *
+                        25 -
+                        20))), 0) /
+            this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 25 - 20))), 0));
+    }
     strainValueAt(current) {
-        const decay = this.strainDecay(current.strainTime);
-        this.currentTapStrain *= decay;
+        this.currentTapStrain *= this.strainDecay(current.strainTime);
         this.currentTapStrain +=
-            DroidTapEvaluator.evaluateDifficultyOf(current, this.greatWindow, true) * this.skillMultiplier;
-        this.currentOriginalTapStrain *= decay;
-        this.currentOriginalTapStrain +=
-            DroidTapEvaluator.evaluateDifficultyOf(current, this.greatWindow, false) * this.skillMultiplier;
-        this.currentOriginalTapStrain *= current.rhythmMultiplier;
+            DroidTapEvaluator.evaluateDifficultyOf(current, this.considerCheesability, this.strainTimeCap) * this.skillMultiplier;
+        this.currentRhythmMultiplier = current.rhythmMultiplier;
+        this._objectDeltaTimes.push(current.deltaTime);
         return this.currentTapStrain * current.rhythmMultiplier;
     }
+    calculateInitialStrain(time, current) {
+        var _a, _b;
+        return (this.currentTapStrain *
+            this.currentRhythmMultiplier *
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
+    }
+    getObjectStrain() {
+        return this.currentTapStrain * this.currentRhythmMultiplier;
+    }
     /**
      * @param current The hitobject to save to.
      */
     saveToHitObject(current) {
-        current.tapStrain = this.currentStrain;
-        current.originalTapStrain = this.currentOriginalTapStrain;
+        if (this.strainTimeCap !== undefined) {
+            return;
+        }
+        const strain = this.currentTapStrain * this.currentRhythmMultiplier;
+        if (this.considerCheesability) {
+            current.tapStrain = strain;
+        }
+        else {
+            current.originalTapStrain = strain;
+        }
     }
 }
 
@@ -1138,12 +969,12 @@ class DroidTap extends DroidSkill {
  * This class should be considered an "evaluating" class and not persisted.
  */
 class FlashlightEvaluator {
-    static maxOpacityBonus = 0.4;
-    static hiddenBonus = 0.2;
-    static minVelocity = 0.5;
-    static sliderMultiplier = 1.3;
-    static minAngleMultiplier = 0.2;
 }
+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.
@@ -1168,7 +999,7 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
             current.isOverlapping(true)) {
             return 0;
         }
-        const scalingFactor = 52 / current.object.getRadius(osuBase.Modes.droid);
+        const scalingFactor = 52 / current.object.radius;
         let smallDistNerf = 1;
         let cumulativeStrainTime = 0;
         let result = 0;
@@ -1193,7 +1024,7 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
                 const opacityBonus = 1 +
                     this.maxOpacityBonus *
                         (1 -
-                            current.opacityAt(currentObject.object.startTime, isHiddenMod, osuBase.Modes.droid));
+                            current.opacityAt(currentObject.object.startTime, isHiddenMod));
                 result +=
                     (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
                         cumulativeStrainTime;
@@ -1224,8 +1055,8 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
             // Longer sliders require more memorization.
             sliderBonus *= pixelTravelDistance;
             // Nerf sliders with repeats, as less memorization is required.
-            if (current.object.repeats > 0)
-                sliderBonus /= current.object.repeats + 1;
+            if (current.object.repeatCount > 0)
+                sliderBonus /= current.object.repeatCount + 1;
         }
         result += sliderBonus * this.sliderMultiplier;
         return result;
@@ -1236,72 +1067,98 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 class DroidFlashlight extends DroidSkill {
-    skillMultiplier = 0.125;
-    strainDecayBase = 0.15;
-    reducedSectionCount = 0;
-    reducedSectionBaseline = 1;
-    starsPerDouble = 1.05;
-    isHidden;
-    withSliders;
     constructor(mods, withSliders) {
         super(mods);
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 0;
+        this.reducedSectionBaseline = 1;
+        this.starsPerDouble = 1.06;
+        this.skillMultiplier = 0.02;
+        this.currentFlashlightStrain = 0;
         this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
         this.withSliders = withSliders;
     }
-    /**
-     * @param current The hitobject to calculate.
-     */
     strainValueAt(current) {
-        this.currentStrain *= this.strainDecay(current.deltaTime);
-        this.currentStrain +=
+        this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
+        this.currentFlashlightStrain +=
             DroidFlashlightEvaluator.evaluateDifficultyOf(current, this.isHidden, this.withSliders) * this.skillMultiplier;
-        return this.currentStrain;
+        return this.currentFlashlightStrain;
+    }
+    calculateInitialStrain(time, current) {
+        var _a, _b;
+        return (this.currentFlashlightStrain *
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
+    }
+    getObjectStrain() {
+        return this.currentFlashlightStrain;
     }
     saveToHitObject(current) {
         if (this.withSliders) {
-            current.flashlightStrainWithSliders = this.currentStrain;
+            current.flashlightStrainWithSliders = this.currentFlashlightStrain;
         }
         else {
-            current.flashlightStrainWithoutSliders = this.currentStrain;
+            current.flashlightStrainWithoutSliders =
+                this.currentFlashlightStrain;
         }
     }
+    difficultyValue() {
+        return (this.strainPeaks.reduce((a, v) => a + v, 0) * this.starsPerDouble);
+    }
 }
 
-/**
- * An evaluator for calculating rhythm skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-class RhythmEvaluator {
-    static rhythmMultiplier = 0.75;
-    static historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
+class Island {
+    constructor(delta, deltaDifferenceEpsilon) {
+        this.delta = Number.MAX_SAFE_INTEGER;
+        this.deltaCount = 0;
+        if (deltaDifferenceEpsilon === undefined) {
+            this.deltaDifferenceEpsilon = delta;
+        }
+        else {
+            this.deltaDifferenceEpsilon = deltaDifferenceEpsilon;
+            this.addDelta(delta);
+        }
+    }
+    addDelta(delta) {
+        if (this.delta === Number.MAX_SAFE_INTEGER) {
+            this.delta = Math.max(Math.trunc(delta), DifficultyHitObject.minDeltaTime);
+        }
+        ++this.deltaCount;
+    }
+    isSimilarPolarity(other) {
+        // TODO: consider islands to be of similar polarity only if they're having the same average delta (we don't want to consider 3 singletaps similar to a triple)
+        // naively adding delta check here breaks _a lot_ of maps because of the flawed ratio calculation
+        return this.deltaCount % 2 == other.deltaCount % 2;
+    }
+    equals(other) {
+        return (Math.abs(this.delta - other.delta) < this.deltaDifferenceEpsilon &&
+            this.deltaCount === other.deltaCount);
+    }
 }
 
 /**
  * An evaluator for calculating osu!droid Rhythm skill.
  */
-class DroidRhythmEvaluator extends RhythmEvaluator {
+class DroidRhythmEvaluator {
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current, greatWindow) {
-        if (current.object instanceof osuBase.Spinner ||
-            // Exclude overlapping objects that can be tapped at once.
-            current.isOverlapping(false)) {
+    static evaluateDifficultyOf(current) {
+        if (current.object instanceof osuBase.Spinner) {
             return 1;
         }
-        let previousIslandSize = 0;
+        const deltaDifferenceEpsilon = current.fullGreatWindow * 0.3;
         let rhythmComplexitySum = 0;
-        let islandSize = 1;
+        let island = new Island(deltaDifferenceEpsilon);
+        let previousIsland = new Island(deltaDifferenceEpsilon);
+        const islandCounts = new Map();
         // Store the ratio of the current start of an island to buff for tighter rhythms.
         let startRatio = 0;
         let firstDeltaSwitch = false;
         let rhythmStart = 0;
-        const historicalNoteCount = Math.min(current.index, 32);
+        const historicalNoteCount = Math.min(current.index, this.historyObjectsMax);
         // Exclude overlapping objects that can be tapped at once.
         const validPrevious = [];
         for (let i = 0; i < historicalNoteCount; ++i) {
@@ -1319,123 +1176,160 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
             ++rhythmStart;
         }
         for (let i = rhythmStart; i > 0; --i) {
+            const currentObject = validPrevious[i - 1];
+            const prevObject = validPrevious[i];
+            const lastObject = validPrevious[i + 1];
             // Scale note 0 to 1 from history to now.
-            let currentHistoricalDecay = (this.historyTimeMax -
-                (current.startTime - validPrevious[i - 1].startTime)) /
+            const timeDecay = (this.historyTimeMax -
+                (current.startTime - currentObject.startTime)) /
                 this.historyTimeMax;
+            const noteDecay = (validPrevious.length - i) / validPrevious.length;
             // Either we're limited by time or limited by object count.
-            currentHistoricalDecay = Math.min(currentHistoricalDecay, (validPrevious.length - i) / validPrevious.length);
-            const currentDelta = validPrevious[i - 1].strainTime;
-            const prevDelta = validPrevious[i].strainTime;
-            const lastDelta = validPrevious[i + 1].strainTime;
+            const currentHistoricalDecay = Math.min(timeDecay, noteDecay);
+            const currentDelta = currentObject.strainTime;
+            const prevDelta = prevObject.strainTime;
+            const lastDelta = lastObject.strainTime;
+            // Calculate how much current delta difference deserves a rhythm bonus
+            // This function is meant to reduce rhythm bonus for deltas that are multiples of each other (i.e. 100 and 200)
+            const deltaDifferenceRatio = Math.min(prevDelta, currentDelta) /
+                Math.max(prevDelta, currentDelta);
             const currentRatio = 1 +
-                6 *
-                    Math.min(0.5, Math.pow(Math.sin(Math.PI /
-                        (Math.min(prevDelta, currentDelta) /
-                            Math.max(prevDelta, currentDelta))), 2));
-            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - greatWindow * 0.4) /
-                (greatWindow * 0.4));
-            let effectiveRatio = windowPenalty * currentRatio;
+                this.rhythmRatioMultiplier *
+                    Math.min(0.5, Math.pow(Math.sin(Math.PI / deltaDifferenceRatio), 2));
+            // Reduce ratio bonus if delta difference is too big
+            const fraction = Math.max(prevDelta / currentDelta, currentDelta / prevDelta);
+            const fractionMultiplier = osuBase.MathUtils.clamp(2 - fraction / 8, 0, 1);
+            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - deltaDifferenceEpsilon) / deltaDifferenceEpsilon);
+            let effectiveRatio = windowPenalty * currentRatio * fractionMultiplier;
             if (firstDeltaSwitch) {
-                if (prevDelta <= 1.25 * currentDelta &&
-                    prevDelta * 1.25 >= currentDelta) {
+                if (Math.abs(prevDelta - currentDelta) < deltaDifferenceEpsilon) {
                     // Island is still progressing, count size.
-                    if (islandSize < 7) {
-                        ++islandSize;
-                    }
+                    island.addDelta(currentDelta);
                 }
                 else {
-                    if (validPrevious[i - 1].object instanceof osuBase.Slider) {
-                        // BPM change is into slider, this is easy acc window.
+                    // BPM change is into slider, this is easy acc window.
+                    if (currentObject.object instanceof osuBase.Slider) {
                         effectiveRatio /= 8;
                     }
-                    if (validPrevious[i].object instanceof osuBase.Slider) {
-                        // BPM change was from a slider, this is typically easier than circle -> circle.
-                        effectiveRatio /= 4;
-                    }
-                    if (previousIslandSize === islandSize) {
-                        // Repeated island size (ex: triplet -> triplet).
-                        effectiveRatio /= 4;
+                    // BPM change was from a slider, this is easier typically than circle -> circle.
+                    // Unintentional side effect is that bursts with kicksliders at the ends might have lower difficulty
+                    // than bursts without sliders.
+                    if (prevObject.object instanceof osuBase.Slider) {
+                        effectiveRatio *= 0.3;
                     }
-                    if (previousIslandSize % 2 === islandSize % 2) {
-                        // Repeated island polarity (2 -> 4, 3 -> 5).
+                    // Repeated island polarity (2 -> 4, 3 -> 5).
+                    if (island.isSimilarPolarity(previousIsland)) {
                         effectiveRatio /= 2;
                     }
-                    if (lastDelta > prevDelta + 10 &&
-                        prevDelta > currentDelta + 10) {
-                        // Previous increase happened a note ago.
-                        // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                    // Previous increase happened a note ago.
+                    // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                    if (lastDelta > prevDelta + deltaDifferenceEpsilon &&
+                        prevDelta > currentDelta + deltaDifferenceEpsilon) {
                         effectiveRatio /= 8;
                     }
+                    // Repeated island size (ex: triplet -> triplet).
+                    // TODO: remove this nerf since its staying here only for balancing purposes because of the flawed ratio calculation
+                    if (previousIsland.deltaCount == island.deltaCount) {
+                        effectiveRatio /= 2;
+                    }
+                    let islandFound = false;
+                    for (const [currentIsland, count] of islandCounts) {
+                        if (!island.equals(currentIsland)) {
+                            continue;
+                        }
+                        islandFound = true;
+                        let islandCount = count;
+                        if (previousIsland.equals(island)) {
+                            // Only add island to island counts if they're going one after another.
+                            ++islandCount;
+                            islandCounts.set(currentIsland, islandCount);
+                        }
+                        // 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))));
+                        break;
+                    }
+                    if (!islandFound) {
+                        islandCounts.set(island, 1);
+                    }
+                    // Scale down the difficulty if the object is doubletappable.
+                    effectiveRatio *= 1 - prevObject.doubletapness * 0.75;
                     rhythmComplexitySum +=
-                        (((Math.sqrt(effectiveRatio * startRatio) *
-                            currentHistoricalDecay *
-                            Math.sqrt(4 + islandSize)) /
-                            2) *
-                            Math.sqrt(4 + previousIslandSize)) /
-                            2;
+                        Math.sqrt(effectiveRatio * startRatio) *
+                            currentHistoricalDecay;
                     startRatio = effectiveRatio;
-                    previousIslandSize = islandSize;
-                    if (prevDelta * 1.25 < currentDelta) {
+                    previousIsland = island;
+                    if (prevDelta + deltaDifferenceEpsilon < currentDelta) {
                         // We're slowing down, stop counting.
                         // If we're speeding up, this stays as is and we keep counting island size.
                         firstDeltaSwitch = false;
                     }
-                    islandSize = 1;
+                    island = new Island(currentDelta, deltaDifferenceEpsilon);
                 }
             }
-            else if (prevDelta > 1.25 * currentDelta) {
-                // We want to be speeding up.
+            else if (prevDelta > currentDelta + deltaDifferenceEpsilon) {
+                // We are speeding up.
                 // Begin counting island until we change speed again.
                 firstDeltaSwitch = true;
+                // BPM change is into slider, this is easy acc window.
+                if (currentObject.object instanceof osuBase.Slider) {
+                    effectiveRatio *= 0.6;
+                }
+                // BPM change was from a slider, this is easier typically than circle -> circle
+                // Unintentional side effect is that bursts with kicksliders at the ends might have lower difficulty
+                // than bursts without sliders
+                if (prevObject.object instanceof osuBase.Slider) {
+                    effectiveRatio *= 0.6;
+                }
                 startRatio = effectiveRatio;
-                islandSize = 1;
+                island = new Island(currentDelta, deltaDifferenceEpsilon);
             }
         }
-        // Nerf doubles that can be tapped at the same time to get Great hit results.
-        const next = current.next(0);
-        let doubletapness = 1;
-        if (next) {
-            const currentDeltaTime = Math.max(1, current.deltaTime);
-            const nextDeltaTime = Math.max(1, next.deltaTime);
-            const deltaDifference = Math.abs(nextDeltaTime - currentDeltaTime);
-            const speedRatio = currentDeltaTime / Math.max(currentDeltaTime, deltaDifference);
-            const windowRatio = Math.pow(Math.min(1, currentDeltaTime / (greatWindow * 2)), 2);
-            doubletapness = Math.pow(speedRatio, 1 - windowRatio);
-        }
-        return (Math.sqrt(4 + rhythmComplexitySum * this.rhythmMultiplier * doubletapness) / 2);
+        return (Math.sqrt(4 + rhythmComplexitySum * this.rhythmOverallMultiplier) /
+            2);
     }
 }
+DroidRhythmEvaluator.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
+DroidRhythmEvaluator.historyObjectsMax = 32;
+DroidRhythmEvaluator.rhythmOverallMultiplier = 0.95;
+DroidRhythmEvaluator.rhythmRatioMultiplier = 12;
 
 /**
  * Represents the skill required to properly follow a beatmap's rhythm.
  */
 class DroidRhythm extends DroidSkill {
-    skillMultiplier = 1;
-    reducedSectionCount = 5;
-    reducedSectionBaseline = 0.75;
-    strainDecayBase = 0.3;
-    starsPerDouble = 1.75;
-    currentRhythm = 1;
-    hitWindow;
-    constructor(mods, overallDifficulty) {
-        super(mods);
-        this.hitWindow = new osuBase.OsuHitWindow(overallDifficulty);
+    constructor() {
+        super(...arguments);
+        this.reducedSectionCount = 5;
+        this.reducedSectionBaseline = 0.75;
+        this.strainDecayBase = 0.3;
+        this.starsPerDouble = 1.75;
+        this.currentRhythmStrain = 0;
+        this.currentRhythmMultiplier = 1;
     }
     strainValueAt(current) {
-        this.currentRhythm = DroidRhythmEvaluator.evaluateDifficultyOf(current, this.hitWindow.hitWindowFor300());
-        this.currentStrain *= this.strainDecay(current.deltaTime);
-        this.currentStrain += this.currentRhythm - 1;
-        return this.currentStrain;
+        this.currentRhythmMultiplier =
+            DroidRhythmEvaluator.evaluateDifficultyOf(current);
+        this.currentRhythmStrain *= this.strainDecay(current.deltaTime);
+        this.currentRhythmStrain += this.currentRhythmMultiplier - 1;
+        return this.currentRhythmStrain;
+    }
+    calculateInitialStrain(time, current) {
+        var _a, _b;
+        return (this.currentRhythmStrain *
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
+    }
+    getObjectStrain() {
+        return this.currentRhythmStrain;
     }
     saveToHitObject(current) {
-        current.rhythmStrain = this.currentStrain;
-        current.rhythmMultiplier = this.currentRhythm;
+        current.rhythmStrain = this.currentRhythmStrain;
+        current.rhythmMultiplier = this.currentRhythmMultiplier;
     }
 }
 
 /**
- * An evaluator for calculating osu!droid Visual skill.
+ * An evaluator for calculating osu!droid visual skill.
  */
 class DroidVisualEvaluator {
     /**
@@ -1456,7 +1350,8 @@ class DroidVisualEvaluator {
     static evaluateDifficultyOf(current, isHiddenMod, withSliders) {
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
-            current.isOverlapping(true)) {
+            current.isOverlapping(true) ||
+            current.index === 0) {
             return 0;
         }
         // Start with base density and give global bonus for Hidden.
@@ -1478,28 +1373,31 @@ class DroidVisualEvaluator {
             }
             // Do not consider objects that don't fall under time preempt.
             if (current.object.startTime - previous.object.endTime >
-                current.baseTimePreempt) {
+                current.object.timePreempt) {
                 break;
             }
             strain +=
                 (1 -
-                    current.opacityAt(previous.object.startTime, isHiddenMod, osuBase.Modes.droid)) /
+                    current.opacityAt(previous.object.startTime, isHiddenMod)) /
                     4;
         }
-        // Scale the value with overlapping factor.
-        strain /= 10 * (1 + current.overlappingFactor);
         if (current.timePreempt < 400) {
             // Give bonus for AR higher than 10.33.
-            strain += Math.pow(400 - current.timePreempt, 1.3) / 100;
+            strain += Math.pow(400 - current.timePreempt, 1.35) / 100;
         }
+        // Scale the value with overlapping factor.
+        strain /= 10 * (1 + current.overlappingFactor);
         if (current.object instanceof osuBase.Slider && withSliders) {
-            const scalingFactor = 50 / current.object.getRadius(osuBase.Modes.droid);
-            // Reward sliders based on velocity.
+            const scalingFactor = 50 / current.object.radius;
+            // Invert the scaling factor to determine the true travel distance independent of circle size.
+            const pixelTravelDistance = current.object.lazyTravelDistance / scalingFactor;
+            const currentVelocity = pixelTravelDistance / current.travelTime;
+            const spanTravelDistance = pixelTravelDistance / current.object.spanCount;
             strain +=
-                // Avoid overbuffing extremely fast sliders.
-                Math.min(6, current.velocity * 1.5) *
-                    // Scale with distance travelled to avoid overbuffing fast sliders with short distance.
-                    Math.min(1, current.travelDistance / scalingFactor / 125);
+                // Reward sliders based on velocity, while also avoiding overbuffing extremely fast sliders.
+                Math.min(6, currentVelocity * 1.5) *
+                    // Longer sliders require more reading.
+                    (spanTravelDistance / 100);
             let cumulativeStrainTime = 0;
             // Reward for velocity changes based on last few sliders.
             for (let i = 0; i < Math.min(current.index, 4); ++i) {
@@ -1510,52 +1408,19 @@ class DroidVisualEvaluator {
                     last.isOverlapping(true)) {
                     continue;
                 }
+                // Invert the scaling factor to determine the true travel distance independent of circle size.
+                const lastPixelTravelDistance = last.object.lazyTravelDistance / scalingFactor;
+                const lastVelocity = lastPixelTravelDistance / last.travelTime;
+                const lastSpanTravelDistance = lastPixelTravelDistance / last.object.spanCount;
                 strain +=
-                    // Avoid overbuffing extremely fast velocity changes.
-                    Math.min(10, 2.5 * Math.abs(current.velocity - last.velocity)) *
-                        // Scale with distance travelled to avoid overbuffing fast sliders with short distance.
-                        Math.min(1, last.travelDistance / scalingFactor / 100) *
-                        // Scale with cumulative strain time to avoid overbuffing past sliders.
-                        Math.min(1, 300 / cumulativeStrainTime);
-            }
-        }
-        // Reward for rhythm changes.
-        if (current.rhythmMultiplier > 1) {
-            let rhythmBonus = (current.rhythmMultiplier - 1) / 20;
-            // Rhythm changes are harder to read in Hidden.
-            // Add additional bonus for Hidden.
-            if (isHiddenMod) {
-                rhythmBonus += (current.rhythmMultiplier - 1) / 25;
-            }
-            // Rhythm changes are harder to read when objects are stacked together.
-            // Scale rhythm bonus based on the stack of past objects.
-            const diameter = 2 * current.object.getRadius(osuBase.Modes.droid);
-            let cumulativeStrainTime = 0;
-            for (let i = 0; i < Math.min(current.index, 5); ++i) {
-                const previous = current.previous(i);
-                if (previous.object instanceof osuBase.Spinner ||
-                    // Exclude overlapping objects that can be tapped at once.
-                    previous.isOverlapping(true)) {
-                    continue;
-                }
-                const jumpDistance = current.object
-                    .getStackedPosition(osuBase.Modes.droid)
-                    .getDistance(previous.object.getStackedEndPosition(osuBase.Modes.droid));
-                cumulativeStrainTime += previous.strainTime;
-                rhythmBonus +=
-                    // Scale the bonus with diameter.
-                    osuBase.MathUtils.clamp((0.5 - jumpDistance / diameter) / 10, 0, 0.05) *
-                        // Scale with cumulative strain time to avoid overbuffing past objects.
+                    // Reward past sliders based on velocity changes, while also
+                    // avoiding overbuffing extremely fast velocity changes.
+                    Math.min(10, 2.5 * Math.abs(currentVelocity - lastVelocity)) *
+                        // Longer sliders require more reading.
+                        (lastSpanTravelDistance / 125) *
+                        // Avoid overbuffing past sliders.
                         Math.min(1, 300 / cumulativeStrainTime);
-                // Give a larger bonus for Hidden.
-                if (isHiddenMod) {
-                    rhythmBonus +=
-                        (1 -
-                            current.opacityAt(previous.object.startTime, isHiddenMod, osuBase.Modes.droid)) /
-                            20;
-                }
             }
-            strain += rhythmBonus;
         }
         return strain;
     }
@@ -1565,31 +1430,239 @@ class DroidVisualEvaluator {
  * Represents the skill required to read every object in the map.
  */
 class DroidVisual extends DroidSkill {
-    starsPerDouble = 1.025;
-    reducedSectionCount = 10;
-    reducedSectionBaseline = 0.75;
-    skillMultiplier = 10;
-    strainDecayBase = 0.1;
-    isHidden;
-    withSliders;
     constructor(mods, withSliders) {
         super(mods);
+        this.starsPerDouble = 1.025;
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.strainDecayBase = 0.1;
+        this.currentVisualStrain = 0;
+        this.currentRhythmMultiplier = 1;
+        this.skillMultiplier = 10;
         this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
         this.withSliders = withSliders;
     }
     strainValueAt(current) {
-        this.currentStrain *= this.strainDecay(current.deltaTime);
-        this.currentStrain +=
+        this.currentVisualStrain *= this.strainDecay(current.deltaTime);
+        this.currentVisualStrain +=
             DroidVisualEvaluator.evaluateDifficultyOf(current, this.isHidden, this.withSliders) * this.skillMultiplier;
-        return this.currentStrain;
+        this.currentRhythmMultiplier = current.rhythmMultiplier;
+        return this.currentVisualStrain * this.currentRhythmMultiplier;
+    }
+    calculateInitialStrain(time, current) {
+        var _a, _b;
+        return (this.currentVisualStrain *
+            this.currentRhythmMultiplier *
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
+    }
+    getObjectStrain() {
+        return this.currentVisualStrain * this.currentRhythmMultiplier;
     }
     saveToHitObject(current) {
+        const strain = this.currentVisualStrain * this.currentRhythmMultiplier;
         if (this.withSliders) {
-            current.visualStrainWithSliders = this.currentStrain;
+            current.visualStrainWithSliders = strain;
         }
         else {
-            current.visualStrainWithoutSliders = this.currentStrain;
+            current.visualStrainWithoutSliders = strain;
+        }
+    }
+}
+
+/**
+ * Represents an osu!droid hit object with difficulty calculation values.
+ */
+class DroidDifficultyHitObject extends DifficultyHitObject {
+    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 = this.normalizedRadius / radius;
+        // High circle size (small CS) bonus
+        if (radius < this.radiusBuffThreshold) {
+            scalingFactor *=
+                1 + Math.pow((this.radiusBuffThreshold - radius) / 50, 2);
+        }
+        return scalingFactor;
+    }
+    /**
+     * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
+     * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue).
+     *
+     * @param object The underlying hitobject.
+     * @param lastObject The hitobject before this hitobject.
+     * @param lastLastObject The hitobject before the last hitobject.
+     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
+     * @param clockRate The clock rate of the beatmap.
+     * @param greatWindow The great window of the hitobject.
+     */
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, greatWindow) {
+        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, greatWindow);
+        /**
+         * The tap strain generated by the hitobject.
+         */
+        this.tapStrain = 0;
+        /**
+         * The tap strain generated by the hitobject if `strainTime` isn't modified by
+         * OD. This is used in three-finger detection.
+         */
+        this.originalTapStrain = 0;
+        /**
+         * The rhythm strain generated by the hitobject.
+         */
+        this.rhythmStrain = 0;
+        /**
+         * The flashlight strain generated by the hitobject if sliders are considered.
+         */
+        this.flashlightStrainWithSliders = 0;
+        /**
+         * The flashlight strain generated by the hitobject if sliders are not considered.
+         */
+        this.flashlightStrainWithoutSliders = 0;
+        /**
+         * The visual strain generated by the hitobject if sliders are considered.
+         */
+        this.visualStrainWithSliders = 0;
+        /**
+         * The visual strain generated by the hitobject if sliders are not considered.
+         */
+        this.visualStrainWithoutSliders = 0;
+        /**
+         * The note density of the hitobject.
+         */
+        this.noteDensity = 1;
+        /**
+         * The overlapping factor of the hitobject.
+         *
+         * This is used to scale visual skill.
+         */
+        this.overlappingFactor = 0;
+        this.radiusBuffThreshold = 70;
+        this.mode = osuBase.Modes.droid;
+        this.maximumSliderRadius = this.normalizedRadius * 2;
+        this.timePreempt = object.timePreempt / clockRate;
+    }
+    computeProperties(clockRate, hitObjects) {
+        super.computeProperties(clockRate, hitObjects);
+        this.setVisuals(clockRate, hitObjects);
+    }
+    /**
+     * Determines whether this hitobject is considered overlapping with the hitobject before it.
+     *
+     * Keep in mind that "overlapping" in this case is overlapping to the point where both hitobjects
+     * can be hit with just a single tap in osu!droid.
+     *
+     * In the case of sliders, it is considered overlapping if all nested hitobjects can be hit with
+     * one aim motion.
+     *
+     * @param considerDistance Whether to consider the distance between both hitobjects.
+     * @returns Whether the hitobject is considered overlapping.
+     */
+    isOverlapping(considerDistance) {
+        if (this.object instanceof osuBase.Spinner) {
+            return false;
+        }
+        const prev = this.previous(0);
+        if (!prev || prev.object instanceof osuBase.Spinner) {
+            return false;
+        }
+        if (this.object.startTime !== prev.object.startTime) {
+            return false;
         }
+        if (!considerDistance) {
+            return true;
+        }
+        const distanceThreshold = 2 * this.object.radius;
+        const startPosition = this.object.getStackedPosition(osuBase.Modes.droid);
+        const prevStartPosition = prev.object.getStackedPosition(osuBase.Modes.droid);
+        // We need to consider two cases:
+        //
+        // Case 1: Current object is a circle, or previous object is a circle.
+        // In this case, we only need to check if their positions are close enough to be tapped together.
+        //
+        // Case 2: Both objects are sliders.
+        // In this case, we need to check if all nested hitobjects can be hit together.
+        // To start with, check if the starting positions can be tapped together.
+        if (startPosition.getDistance(prevStartPosition) > distanceThreshold) {
+            return false;
+        }
+        if (this.object instanceof osuBase.Circle || prev.object instanceof osuBase.Circle) {
+            return true;
+        }
+        // Check if all nested hitobjects can be hit together.
+        for (let i = 1; i < this.object.nestedHitObjects.length; ++i) {
+            const position = this.object.nestedHitObjects[i].getStackedPosition(osuBase.Modes.droid);
+            const prevPosition = prevStartPosition.add(prev.object.curvePositionAt(i / (this.object.nestedHitObjects.length - 1)));
+            if (position.getDistance(prevPosition) > distanceThreshold) {
+                return false;
+            }
+        }
+        // Do the same for the previous slider as well.
+        for (let i = 1; i < prev.object.nestedHitObjects.length; ++i) {
+            const prevPosition = prev.object.nestedHitObjects[i].getStackedPosition(osuBase.Modes.droid);
+            const position = startPosition.add(this.object.curvePositionAt(i / (prev.object.nestedHitObjects.length - 1)));
+            if (prevPosition.getDistance(position) > distanceThreshold) {
+                return false;
+            }
+        }
+        return true;
+    }
+    setVisuals(clockRate, hitObjects) {
+        // We'll have two visible object arrays. The first array contains objects before the current object starts in a reversed order,
+        // while the second array contains objects after the current object ends.
+        // For overlapping factor, we also need to consider previous visible objects.
+        const prevVisibleObjects = [];
+        const nextVisibleObjects = [];
+        for (let j = this.index + 2; j < hitObjects.length; ++j) {
+            const o = hitObjects[j];
+            if (o instanceof osuBase.Spinner) {
+                continue;
+            }
+            if (o.startTime / clockRate > this.endTime + this.timePreempt) {
+                break;
+            }
+            nextVisibleObjects.push(o);
+        }
+        for (let j = 0; j < this.index; ++j) {
+            const prev = this.previous(j);
+            if (prev.object instanceof osuBase.Spinner) {
+                continue;
+            }
+            if (prev.startTime >= this.startTime) {
+                continue;
+            }
+            if (prev.startTime < this.startTime - this.timePreempt) {
+                break;
+            }
+            prevVisibleObjects.push(prev.object);
+        }
+        for (const hitObject of prevVisibleObjects) {
+            const distance = this.object
+                .getStackedPosition(this.mode)
+                .getDistance(hitObject.getStackedEndPosition(this.mode));
+            const deltaTime = this.startTime - hitObject.endTime / clockRate;
+            this.applyToOverlappingFactor(distance, deltaTime);
+        }
+        for (const hitObject of nextVisibleObjects) {
+            const distance = hitObject
+                .getStackedPosition(this.mode)
+                .getDistance(this.object.getStackedEndPosition(this.mode));
+            const deltaTime = hitObject.startTime / clockRate - this.endTime;
+            if (deltaTime >= 0) {
+                this.noteDensity += 1 - deltaTime / this.timePreempt;
+            }
+            this.applyToOverlappingFactor(distance, deltaTime);
+        }
+    }
+    applyToOverlappingFactor(distance, deltaTime) {
+        // Penalize objects that are too close to the object in both distance
+        // and delta time to prevent stream maps from being overweighted.
+        this.overlappingFactor +=
+            Math.max(0, 1 - distance / (2.5 * this.object.radius)) *
+                (7.5 /
+                    (1 +
+                        Math.exp(0.15 *
+                            (Math.max(deltaTime, DifficultyHitObject.minDeltaTime) -
+                                75))));
     }
 }
 
@@ -1597,56 +1670,77 @@ class DroidVisual extends DroidSkill {
  * A difficulty calculator for osu!droid gamemode.
  */
 class DroidDifficultyCalculator extends DifficultyCalculator {
+    constructor() {
+        super(...arguments);
+        this.attributes = {
+            mode: "live",
+            tapDifficulty: 0,
+            rhythmDifficulty: 0,
+            visualDifficulty: 0,
+            aimNoteCount: 0,
+            mods: [],
+            starRating: 0,
+            maxCombo: 0,
+            aimDifficulty: 0,
+            flashlightDifficulty: 0,
+            speedNoteCount: 0,
+            sliderFactor: 0,
+            clockRate: 1,
+            overallDifficulty: 0,
+            hitCircleCount: 0,
+            sliderCount: 0,
+            spinnerCount: 0,
+            aimDifficultStrainCount: 0,
+            tapDifficultStrainCount: 0,
+            flashlightDifficultStrainCount: 0,
+            visualDifficultStrainCount: 0,
+            flashlightSliderFactor: 0,
+            visualSliderFactor: 0,
+            possibleThreeFingeredSections: [],
+            difficultSliders: [],
+            averageSpeedDeltaTime: 0,
+            vibroFactor: 1,
+        };
+        this.difficultyMultiplier = 0.18;
+        this.mode = osuBase.Modes.droid;
+    }
     /**
      * The aim star rating of the beatmap.
      */
-    aim = 0;
+    get aim() {
+        return this.attributes.aimDifficulty;
+    }
     /**
      * The tap star rating of the beatmap.
      */
-    tap = 0;
+    get tap() {
+        return this.attributes.tapDifficulty;
+    }
     /**
      * The rhythm star rating of the beatmap.
      */
-    rhythm = 0;
+    get rhythm() {
+        return this.attributes.rhythmDifficulty;
+    }
     /**
      * The flashlight star rating of the beatmap.
      */
-    flashlight = 0;
+    get flashlight() {
+        return this.attributes.flashlightDifficulty;
+    }
     /**
      * The visual star rating of the beatmap.
      */
-    visual = 0;
-    /**
-     * The strain threshold to start detecting for possible three-fingered section.
-     *
-     * Increasing this number will result in less sections being flagged.
-     */
-    static threeFingerStrainThreshold = 175;
-    attributes = {
-        tapDifficulty: 0,
-        rhythmDifficulty: 0,
-        visualDifficulty: 0,
-        aimNoteCount: 0,
-        mods: [],
-        starRating: 0,
-        maxCombo: 0,
-        aimDifficulty: 0,
-        flashlightDifficulty: 0,
-        speedNoteCount: 0,
-        sliderFactor: 0,
-        approachRate: 0,
-        overallDifficulty: 0,
-        hitCircleCount: 0,
-        sliderCount: 0,
-        spinnerCount: 0,
-        flashlightSliderFactor: 0,
-        visualSliderFactor: 0,
-        possibleThreeFingeredSections: [],
-        difficultSliders: [],
-    };
-    difficultyMultiplier = 0.18;
-    mode = osuBase.Modes.droid;
+    get visual() {
+        return this.attributes.visualDifficulty;
+    }
+    get cacheableAttributes() {
+        return Object.assign(Object.assign({}, this.attributes), { mods: osuBase.ModUtil.modsToOsuString(this.attributes.mods) });
+    }
+    // Override to use DroidDifficultyCalculationOptions
+    calculate(options) {
+        return super.calculate(options);
+    }
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -1660,26 +1754,18 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * Calculates the tap star rating of the beatmap and stores it in this instance.
      */
     calculateTap() {
-        const tapSkill = new DroidTap(this.mods, this.stats.od);
-        this.calculateSkills(tapSkill);
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.tap = this.attributes.tapDifficulty = 0;
-            this.attributes.possibleThreeFingeredSections = [];
-        }
-        else {
-            this.postCalculateTap(tapSkill);
-        }
-        this.calculateSpeedAttributes();
+        const tapSkillCheese = new DroidTap(this.mods, true);
+        const tapSkillNoCheese = new DroidTap(this.mods, false);
+        this.calculateSkills(tapSkillCheese, tapSkillNoCheese);
+        const tapSkillVibro = new DroidTap(this.mods, true, tapSkillCheese.relevantDeltaTime());
+        this.calculateSkills(tapSkillVibro);
+        this.postCalculateTap(tapSkillCheese, tapSkillVibro);
     }
     /**
      * Calculates the rhythm star rating of the beatmap and stores it in this instance.
      */
     calculateRhythm() {
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.rhythm = this.attributes.rhythmDifficulty = 0;
-            return;
-        }
-        const rhythmSkill = new DroidRhythm(this.mods, this.stats.od);
+        const rhythmSkill = new DroidRhythm(this.mods);
         this.calculateSkills(rhythmSkill);
         this.postCalculateRhythm(rhythmSkill);
     }
@@ -1697,7 +1783,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      */
     calculateVisual() {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.visual = this.attributes.visualDifficulty = 0;
+            this.attributes.visualDifficulty = 0;
             return;
         }
         const visualSkill = new DroidVisual(this.mods, true);
@@ -1719,55 +1805,35 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         if (basePerformanceValue > 1e-5) {
             // Document for formula derivation:
             // https://docs.google.com/document/d/10DZGYYSsT_yjz2Mtp6yIJld0Rqx4E-vVHupCqiM4TNI/edit
-            this.total = this.attributes.starRating =
+            this.attributes.starRating =
                 0.027 *
                     (Math.cbrt((100000 / Math.pow(2, 1 / 1.1)) * basePerformanceValue) +
                         4);
         }
         else {
-            this.total = this.attributes.starRating = 0;
+            this.attributes.starRating = 0;
         }
     }
     calculateAll() {
         const skills = this.createSkills();
-        const isRelax = this.mods.some((m) => m instanceof osuBase.ModRelax);
-        if (isRelax) {
-            // Remove visual skills to reduce overhead.
-            skills.pop();
-            skills.pop();
-        }
         this.calculateSkills(...skills);
         const aimSkill = skills[0];
         const aimSkillWithoutSliders = skills[1];
         const rhythmSkill = skills[2];
-        const tapSkill = skills[3];
-        const flashlightSkill = skills[4];
-        const flashlightSkillWithoutSliders = skills[5];
-        const visualSkill = skills[6] ?? null;
-        const visualSkillWithoutSliders = skills[7] ?? null;
+        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);
-        if (isRelax) {
-            this.tap = this.attributes.tapDifficulty = 0;
-        }
-        else {
-            this.postCalculateTap(tapSkill);
-        }
-        this.calculateSpeedAttributes();
-        if (!isRelax) {
-            this.postCalculateRhythm(rhythmSkill);
-        }
+        this.postCalculateTap(tapSkillCheese, tapSkillVibro);
+        this.postCalculateRhythm(rhythmSkill);
         this.postCalculateFlashlight(flashlightSkill, flashlightSkillWithoutSliders);
-        if (visualSkill && visualSkillWithoutSliders) {
-            this.postCalculateVisual(visualSkill, visualSkillWithoutSliders);
-        }
-        else {
-            this.visual = this.attributes.visualDifficulty = 0;
-        }
+        this.postCalculateVisual(visualSkill, visualSkillWithoutSliders);
         this.calculateTotal();
     }
-    /**
-     * Returns a string representative of the class.
-     */
     toString() {
         return (this.total.toFixed(2) +
             " stars (" +
@@ -1782,22 +1848,39 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             this.visual.toFixed(2) +
             " visual)");
     }
-    /**
-     * Creates skills to be calculated.
-     */
+    generateDifficultyHitObjects(beatmap, clockRate) {
+        var _a, _b;
+        const difficultyObjects = [];
+        const { objects } = beatmap.hitObjects;
+        const isPrecise = this.mods.some((m) => m instanceof osuBase.ModPrecise);
+        const greatWindow = new osuBase.DroidHitWindow(beatmap.difficulty.od).hitWindowFor300(isPrecise) / clockRate;
+        for (let i = 0; i < objects.length; ++i) {
+            const difficultyObject = new DroidDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, (_b = objects[i - 2]) !== null && _b !== void 0 ? _b : null, difficultyObjects, clockRate, greatWindow);
+            difficultyObject.computeProperties(clockRate, objects);
+            difficultyObjects.push(difficultyObject);
+        }
+        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, this.stats.od),
-            new DroidTap(this.mods, this.stats.od),
+            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),
         ];
     }
+    calculateClockRate(options) {
+        var _a, _b;
+        return (osuBase.ModUtil.calculateRateWithMods((_a = options === null || options === void 0 ? void 0 : options.mods) !== null && _a !== void 0 ? _a : [], options === null || options === void 0 ? void 0 : options.oldStatistics) * ((_b = options === null || options === void 0 ? void 0 : options.customSpeedMultiplier) !== null && _b !== void 0 ? _b : 1));
+    }
     /**
      * Called after aim skill calculation.
      *
@@ -1807,152 +1890,122 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     postCalculateAim(aimSkill, aimSkillWithoutSliders) {
         this.strainPeaks.aimWithSliders = aimSkill.strainPeaks;
         this.strainPeaks.aimWithoutSliders = aimSkillWithoutSliders.strainPeaks;
-        this.aim = this.starValue(aimSkill.difficultyValue());
+        this.attributes.aimDifficulty = this.mods.some((m) => m instanceof osuBase.ModAutopilot)
+            ? 0
+            : this.starValue(aimSkill.difficultyValue());
         if (this.aim) {
             this.attributes.sliderFactor =
                 this.starValue(aimSkillWithoutSliders.difficultyValue()) /
                     this.aim;
         }
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.aim *= 0.9;
+            this.attributes.aimDifficulty *= 0.9;
         }
-        this.attributes.aimDifficulty = this.aim;
+        this.attributes.aimDifficultStrainCount =
+            aimSkill.countDifficultStrains();
         this.calculateAimAttributes();
     }
     /**
      * Calculates aim-related attributes.
      */
     calculateAimAttributes() {
-        const objectStrains = [];
-        let maxStrain = 0;
-        // Take the top 15% most difficult sliders based on velocity.
+        this.attributes.difficultSliders = [];
         const topDifficultSliders = [];
         for (let i = 0; i < this.objects.length; ++i) {
             const object = this.objects[i];
-            objectStrains.push(object.aimStrainWithSliders);
-            maxStrain = Math.max(maxStrain, object.aimStrainWithSliders);
             const velocity = object.travelDistance / object.travelTime;
             if (velocity > 0) {
                 topDifficultSliders.push({
                     index: i,
                     velocity: velocity,
                 });
-                topDifficultSliders.sort((a, b) => b.velocity - a.velocity);
-                while (topDifficultSliders.length >
-                    Math.ceil(0.15 * this.beatmap.hitObjects.sliders)) {
-                    topDifficultSliders.pop();
-                }
             }
         }
-        if (maxStrain) {
-            this.attributes.aimNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
-        }
         const velocitySum = topDifficultSliders.reduce((a, v) => a + v.velocity, 0);
         for (const slider of topDifficultSliders) {
-            this.attributes.difficultSliders.push({
-                index: slider.index,
-                difficultyRating: slider.velocity / velocitySum,
-            });
+            const difficultyRating = slider.velocity / velocitySum;
+            // Only consider sliders that are fast enough.
+            if (difficultyRating > 0.02) {
+                this.attributes.difficultSliders.push({
+                    index: slider.index,
+                    difficultyRating: slider.velocity / velocitySum,
+                });
+            }
+        }
+        this.attributes.difficultSliders.sort((a, b) => b.difficultyRating - a.difficultyRating);
+        // Take the top 15% most difficult sliders.
+        while (this.attributes.difficultSliders.length >
+            Math.ceil(0.15 * this.beatmap.hitObjects.sliders)) {
+            this.attributes.difficultSliders.pop();
         }
     }
     /**
      * Called after tap skill calculation.
      *
-     * @param tapSkill The tap skill.
+     * @param tapSkillCheese The tap skill that considers cheesing.
+     * @param tapSkillVibro The tap skill that considers vibro.
      */
-    postCalculateTap(tapSkill) {
-        this.strainPeaks.speed = tapSkill.strainPeaks;
-        this.tap = this.attributes.tapDifficulty = this.starValue(tapSkill.difficultyValue());
+    postCalculateTap(tapSkillCheese, tapSkillVibro) {
+        this.strainPeaks.speed = tapSkillCheese.strainPeaks;
+        this.attributes.tapDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
+            ? 0
+            : this.starValue(tapSkillCheese.difficultyValue());
+        if (this.tap) {
+            this.attributes.vibroFactor =
+                this.starValue(tapSkillVibro.difficultyValue()) / this.tap;
+        }
+        this.attributes.speedNoteCount = tapSkillCheese.relevantNoteCount();
+        this.attributes.averageSpeedDeltaTime =
+            tapSkillCheese.relevantDeltaTime();
+        this.attributes.tapDifficultStrainCount =
+            tapSkillCheese.countDifficultStrains();
+        this.calculateTapAttributes();
     }
     /**
-     * Calculates speed-related attributes.
+     * Calculates tap-related attributes.
      */
-    calculateSpeedAttributes() {
+    calculateTapAttributes() {
         this.attributes.possibleThreeFingeredSections = [];
-        const tempSections = [];
-        const objectStrains = [];
-        let maxStrain = 0;
-        const maxSectionDeltaTime = 2000;
+        const { threeFingerStrainThreshold } = DroidDifficultyCalculator;
         const minSectionObjectCount = 5;
-        let firstObjectIndex = 0;
-        for (let i = 0; i < this.objects.length - 1; ++i) {
+        let inSpeedSection = false;
+        let firstSpeedObjectIndex = 0;
+        for (let i = 2; i < this.objects.length; ++i) {
             const current = this.objects[i];
-            const next = this.objects[i + 1];
-            if (i === 0) {
-                objectStrains.push(current.tapStrain);
+            const prev = this.objects[i - 1];
+            if (!inSpeedSection &&
+                current.originalTapStrain >= threeFingerStrainThreshold) {
+                inSpeedSection = true;
+                firstSpeedObjectIndex = i;
+                continue;
             }
-            objectStrains.push(next.tapStrain);
-            maxStrain = Math.max(current.tapStrain, maxStrain);
-            const realDeltaTime = next.object.startTime - current.object.endTime;
-            if (realDeltaTime >= maxSectionDeltaTime) {
+            const currentDelta = current.deltaTime;
+            const prevDelta = prev.deltaTime;
+            const deltaRatio = Math.min(prevDelta, currentDelta) /
+                Math.max(prevDelta, currentDelta);
+            if (inSpeedSection &&
+                (current.originalTapStrain < threeFingerStrainThreshold ||
+                    // Stop speed section on slowing down 1/2 rhythm change or anything slower.
+                    (prevDelta < currentDelta && deltaRatio <= 0.5) ||
+                    // Don't forget to manually add the last section, which would otherwise be ignored.
+                    i === this.objects.length - 1)) {
+                const lastSpeedObjectIndex = i - (i === this.objects.length - 1 ? 0 : 1);
+                inSpeedSection = false;
                 // Ignore sections that don't meet object count requirement.
-                if (i - firstObjectIndex < minSectionObjectCount) {
-                    firstObjectIndex = i + 1;
-                    continue;
-                }
-                tempSections.push({
-                    firstObjectIndex,
-                    lastObjectIndex: i,
-                });
-                firstObjectIndex = i + 1;
-            }
-        }
-        // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
-        if (this.objects.length - firstObjectIndex > minSectionObjectCount) {
-            tempSections.push({
-                firstObjectIndex,
-                lastObjectIndex: this.objects.length - 1,
-            });
-        }
-        // Refilter with tap strain in mind.
-        const { threeFingerStrainThreshold } = DroidDifficultyCalculator;
-        for (const section of tempSections) {
-            let inSpeedSection = false;
-            let newFirstObjectIndex = section.firstObjectIndex;
-            for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
-                const current = this.objects[i];
-                if (!inSpeedSection &&
-                    current.originalTapStrain >= threeFingerStrainThreshold) {
-                    inSpeedSection = true;
-                    newFirstObjectIndex = i;
+                if (i - firstSpeedObjectIndex < minSectionObjectCount) {
                     continue;
                 }
-                if (inSpeedSection &&
-                    current.originalTapStrain < threeFingerStrainThreshold) {
-                    inSpeedSection = false;
-                    this.attributes.possibleThreeFingeredSections.push({
-                        firstObjectIndex: newFirstObjectIndex,
-                        lastObjectIndex: i,
-                        sumStrain: this.calculateThreeFingerSummedStrain(newFirstObjectIndex, i),
-                    });
-                }
-            }
-            // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
-            if (inSpeedSection) {
                 this.attributes.possibleThreeFingeredSections.push({
-                    firstObjectIndex: newFirstObjectIndex,
-                    lastObjectIndex: section.lastObjectIndex,
-                    sumStrain: this.calculateThreeFingerSummedStrain(newFirstObjectIndex, section.lastObjectIndex),
+                    firstObjectIndex: firstSpeedObjectIndex,
+                    lastObjectIndex: lastSpeedObjectIndex,
+                    sumStrain: Math.pow(this.objects
+                        .slice(firstSpeedObjectIndex, lastSpeedObjectIndex + 1)
+                        .reduce((a, v) => a +
+                        v.originalTapStrain /
+                            threeFingerStrainThreshold, 0), 0.75),
                 });
             }
         }
-        if (maxStrain) {
-            this.attributes.speedNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
-        }
-    }
-    /**
-     * Calculates the sum of strains for possible three-fingered sections.
-     *
-     * @param firstObjectIndex The index of the first object in the section.
-     * @param lastObjectIndex The index of the last object in the section.
-     * @returns The summed strain of the section.
-     */
-    calculateThreeFingerSummedStrain(firstObjectIndex, lastObjectIndex) {
-        return Math.pow(this.objects
-            .slice(firstObjectIndex, lastObjectIndex)
-            .reduce((a, v) => a +
-            v.originalTapStrain /
-                DroidDifficultyCalculator.threeFingerStrainThreshold, 0), 0.75);
     }
     /**
      * Called after rhythm skill calculation.
@@ -1960,7 +2013,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * @param rhythmSkill The rhythm skill.
      */
     postCalculateRhythm(rhythmSkill) {
-        this.rhythm = this.attributes.rhythmDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
+        this.attributes.rhythmDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
             ? 0
             : this.starValue(rhythmSkill.difficultyValue());
     }
@@ -1972,15 +2025,19 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      */
     postCalculateFlashlight(flashlightSkill, flashlightSkillWithoutSliders) {
         this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
-        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+        this.attributes.flashlightDifficulty = this.starValue(flashlightSkill.difficultyValue());
         if (this.flashlight) {
             this.attributes.flashlightSliderFactor =
                 this.starValue(flashlightSkillWithoutSliders.difficultyValue()) / this.flashlight;
         }
+        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            this.attributes.flashlightDifficulty *= 0.3;
+        }
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.flashlight *= 0.7;
+            this.attributes.flashlightDifficulty *= 0.7;
         }
-        this.attributes.flashlightDifficulty = this.flashlight;
+        this.attributes.flashlightDifficultStrainCount =
+            flashlightSkill.countDifficultStrains();
     }
     /**
      * Called after visual skill calculation.
@@ -1989,7 +2046,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * @param visualSkillWithoutSliders The visual skill that doesn't consider sliders.
      */
     postCalculateVisual(visualSkillWithSliders, visualSkillWithoutSliders) {
-        this.visual = this.attributes.visualDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
+        this.attributes.visualDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
             ? 0
             : this.starValue(visualSkillWithSliders.difficultyValue());
         if (this.visual) {
@@ -1997,33 +2054,51 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
                 this.starValue(visualSkillWithoutSliders.difficultyValue()) /
                     this.visual;
         }
+        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            this.attributes.visualDifficulty *= 0.8;
+        }
+        this.attributes.visualDifficultStrainCount =
+            visualSkillWithSliders.countDifficultStrains();
     }
 }
+/**
+ * The strain threshold to start detecting for possible three-fingered section.
+ *
+ * Increasing this number will result in less sections being flagged.
+ */
+DroidDifficultyCalculator.threeFingerStrainThreshold = 175;
 
 /**
  * The base class of performance calculators.
  */
 class PerformanceCalculator {
     /**
-     * The overall performance value.
-     */
-    total = 0;
-    /**
-     * The calculated accuracy.
-     */
-    computedAccuracy = new osuBase.Accuracy({});
-    /**
-     * Penalty for combo breaks.
-     */
-    comboPenalty = 0;
-    /**
-     * The amount of misses that are filtered out from sliderbreaks.
-     */
-    effectiveMissCount = 0;
-    /**
-     * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
+     * @param difficultyAttributes The difficulty attributes to calculate.
      */
-    sliderNerfFactor = 1;
+    constructor(difficultyAttributes) {
+        /**
+         * The overall performance value.
+         */
+        this.total = 0;
+        /**
+         * The calculated accuracy.
+         */
+        this.computedAccuracy = new osuBase.Accuracy({});
+        /**
+         * The amount of misses that are filtered out from sliderbreaks.
+         */
+        this.effectiveMissCount = 0;
+        /**
+         * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
+         */
+        this.sliderNerfFactor = 1;
+        if (this.isCacheableAttribute(difficultyAttributes)) {
+            this.difficultyAttributes = Object.assign(Object.assign({}, difficultyAttributes), { mods: osuBase.ModUtil.pcStringToMods(difficultyAttributes.mods) });
+        }
+        else {
+            this.difficultyAttributes = osuBase.Utils.deepCopy(difficultyAttributes);
+        }
+    }
     /**
      * Calculates the performance points of the beatmap.
      *
@@ -2033,7 +2108,7 @@ class PerformanceCalculator {
     calculate(options) {
         this.handleOptions(options);
         this.calculateValues();
-        this.calculateTotalValue();
+        this.total = this.calculateTotalValue();
         return this;
     }
     /**
@@ -2064,11 +2139,11 @@ class PerformanceCalculator {
      * @param options Options for performance calculation.
      */
     handleOptions(options) {
+        var _a;
         const maxCombo = this.difficultyAttributes.maxCombo;
         const miss = this.computedAccuracy.nmiss;
-        const combo = options?.combo ?? maxCombo - miss;
-        this.comboPenalty = Math.min(Math.pow(combo / maxCombo, 0.8), 1);
-        if (options?.accPercent instanceof osuBase.Accuracy) {
+        const combo = (_a = options === null || options === void 0 ? void 0 : options.combo) !== null && _a !== void 0 ? _a : maxCombo - miss;
+        if ((options === null || options === void 0 ? void 0 : options.accPercent) instanceof osuBase.Accuracy) {
             // Copy into new instance to not modify the original
             this.computedAccuracy = new osuBase.Accuracy(options.accPercent);
             if (this.computedAccuracy.n300 <= 0) {
@@ -2083,9 +2158,9 @@ class PerformanceCalculator {
         }
         else {
             this.computedAccuracy = new osuBase.Accuracy({
-                percent: options?.accPercent,
+                percent: options === null || options === void 0 ? void 0 : options.accPercent,
                 nobjects: this.totalHits,
-                nmiss: options?.miss || 0,
+                nmiss: (options === null || options === void 0 ? void 0 : options.miss) || 0,
             });
         }
         this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo);
@@ -2105,7 +2180,7 @@ class PerformanceCalculator {
                     Math.pow(this.difficultyAttributes.overallDifficulty /
                         13.33, 1.8)
                 : 1);
-            const n50Multiplier = Math.max(0, this.difficultyAttributes.overallDifficulty > 0.0
+            const n50Multiplier = Math.max(0, this.difficultyAttributes.overallDifficulty > 0
                 ? 1 -
                     Math.pow(this.difficultyAttributes.overallDifficulty /
                         13.33, 5)
@@ -2119,7 +2194,7 @@ class PerformanceCalculator {
         if (this.difficultyAttributes.sliderCount > 0) {
             // We assume 15% of sliders in a beatmap are difficult since there's no way to tell from the performance calculator.
             const estimateDifficultSliders = this.difficultyAttributes.sliderCount * 0.15;
-            const estimateSliderEndsDropped = osuBase.MathUtils.clamp(Math.min(this.computedAccuracy.n300 +
+            const estimateSliderEndsDropped = osuBase.MathUtils.clamp(Math.min(this.computedAccuracy.n100 +
                 this.computedAccuracy.n50 +
                 this.computedAccuracy.nmiss, maxCombo - combo), 0, estimateDifficultSliders);
             this.sliderNerfFactor =
@@ -2130,6 +2205,22 @@ class PerformanceCalculator {
                     this.difficultyAttributes.sliderFactor;
         }
     }
+    /**
+     * Calculates a strain-based miss penalty.
+     *
+     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    calculateStrainBasedMissPenalty(difficultStrainCount) {
+        if (this.effectiveMissCount === 0) {
+            return 1;
+        }
+        return (0.96 /
+            (this.effectiveMissCount /
+                (4 * Math.pow(Math.log(difficultStrainCount), 0.94)) +
+                1));
+    }
     /**
      * Calculates the amount of misses + sliderbreaks from combo.
      */
@@ -2147,32 +2238,52 @@ class PerformanceCalculator {
         }
         return Math.max(this.computedAccuracy.nmiss, comboBasedMissCount);
     }
+    /**
+     * Determines whether an attribute is a cacheable attribute.
+     *
+     * @param attributes The attributes to check.
+     * @returns Whether the attributes are cacheable.
+     */
+    isCacheableAttribute(attributes) {
+        return typeof attributes.mods === "string";
+    }
 }
 
 /**
  * A performance points calculator that calculates performance points for osu!droid gamemode.
  */
 class DroidPerformanceCalculator extends PerformanceCalculator {
-    /**
-     * The aim performance value.
-     */
-    aim = 0;
-    /**
-     * The tap performance value.
-     */
-    tap = 0;
-    /**
-     * The accuracy performance value.
-     */
-    accuracy = 0;
-    /**
-     * The flashlight performance value.
-     */
-    flashlight = 0;
-    /**
-     * The visual performance value.
-     */
-    visual = 0;
+    constructor() {
+        super(...arguments);
+        /**
+         * The aim performance value.
+         */
+        this.aim = 0;
+        /**
+         * The tap performance value.
+         */
+        this.tap = 0;
+        /**
+         * The accuracy performance value.
+         */
+        this.accuracy = 0;
+        /**
+         * The flashlight performance value.
+         */
+        this.flashlight = 0;
+        /**
+         * The visual performance value.
+         */
+        this.visual = 0;
+        this.finalMultiplier = 1.24;
+        this.mode = osuBase.Modes.droid;
+        this._aimSliderCheesePenalty = 1;
+        this._flashlightSliderCheesePenalty = 1;
+        this._visualSliderCheesePenalty = 1;
+        this._tapPenalty = 1;
+        this._deviation = 0;
+        this._tapDeviation = 0;
+    }
     /**
      * The penalty used to penalize the tap performance value.
      *
@@ -2217,22 +2328,6 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
     get visualSliderCheesePenalty() {
         return this._visualSliderCheesePenalty;
     }
-    difficultyAttributes;
-    finalMultiplier = 1.24;
-    mode = osuBase.Modes.droid;
-    _aimSliderCheesePenalty = 1;
-    _flashlightSliderCheesePenalty = 1;
-    _visualSliderCheesePenalty = 1;
-    _tapPenalty = 1;
-    _deviation = 0;
-    _tapDeviation = 0;
-    /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
-     */
-    constructor(difficultyAttributes) {
-        super();
-        this.difficultyAttributes = osuBase.Utils.deepCopy(difficultyAttributes);
-    }
     /**
      * Applies a tap penalty value to this calculator.
      *
@@ -2247,9 +2342,9 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (value === this._tapPenalty) {
             return;
         }
-        this.tap *= this._tapPenalty / value;
         this._tapPenalty = value;
-        this.calculateTotalValue();
+        this.tap = this.calculateTapValue();
+        this.total = this.calculateTotalValue();
     }
     /**
      * Applies an aim slider cheese penalty value to this calculator.
@@ -2269,8 +2364,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return;
         }
         this._aimSliderCheesePenalty = value;
-        this.calculateAimValue();
-        this.calculateTotalValue();
+        this.aim = this.calculateAimValue();
+        this.total = this.calculateTotalValue();
     }
     /**
      * Applies a flashlight slider cheese penalty value to this calculator.
@@ -2290,8 +2385,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return;
         }
         this._flashlightSliderCheesePenalty = value;
-        this.calculateFlashlightValue();
-        this.calculateTotalValue();
+        this.flashlight = this.calculateFlashlightValue();
+        this.total = this.calculateTotalValue();
     }
     /**
      * Applies a visual slider cheese penalty value to this calculator.
@@ -2311,80 +2406,96 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return;
         }
         this._visualSliderCheesePenalty = value;
-        this.calculateVisualValue();
-        this.calculateTotalValue();
+        this.visual = this.calculateVisualValue();
+        this.total = this.calculateTotalValue();
     }
     calculateValues() {
         this._deviation = this.calculateDeviation();
         this._tapDeviation = this.calculateTapDeviation();
-        this.calculateAimValue();
-        this.calculateTapValue();
-        this.calculateAccuracyValue();
-        this.calculateFlashlightValue();
-        this.calculateVisualValue();
+        this.aim = this.calculateAimValue();
+        this.tap = this.calculateTapValue();
+        this.accuracy = this.calculateAccuracyValue();
+        this.flashlight = this.calculateFlashlightValue();
+        this.visual = this.calculateVisualValue();
     }
     calculateTotalValue() {
-        this.total =
-            Math.pow(Math.pow(this.aim, 1.1) +
-                Math.pow(this.tap, 1.1) +
-                Math.pow(this.accuracy, 1.1) +
-                Math.pow(this.flashlight, 1.1) +
-                Math.pow(this.visual, 1.1), 1 / 1.1) * this.finalMultiplier;
+        return (Math.pow(Math.pow(this.aim, 1.1) +
+            Math.pow(this.tap, 1.1) +
+            Math.pow(this.accuracy, 1.1) +
+            Math.pow(this.flashlight, 1.1) +
+            Math.pow(this.visual, 1.1), 1 / 1.1) * this.finalMultiplier);
     }
     handleOptions(options) {
-        this._tapPenalty = options?.tapPenalty ?? 1;
-        this._aimSliderCheesePenalty = options?.aimSliderCheesePenalty ?? 1;
+        var _a, _b, _c, _d;
+        this._tapPenalty = (_a = options === null || options === void 0 ? void 0 : options.tapPenalty) !== null && _a !== void 0 ? _a : 1;
+        this._aimSliderCheesePenalty = (_b = options === null || options === void 0 ? void 0 : options.aimSliderCheesePenalty) !== null && _b !== void 0 ? _b : 1;
         this._flashlightSliderCheesePenalty =
-            options?.flashlightSliderCheesePenalty ?? 1;
+            (_c = options === null || options === void 0 ? void 0 : options.flashlightSliderCheesePenalty) !== null && _c !== void 0 ? _c : 1;
         this._visualSliderCheesePenalty =
-            options?.visualSliderCheesePenalty ?? 1;
+            (_d = options === null || options === void 0 ? void 0 : options.visualSliderCheesePenalty) !== null && _d !== void 0 ? _d : 1;
         super.handleOptions(options);
     }
     /**
      * Calculates the aim performance value of the beatmap.
      */
     calculateAimValue() {
-        this.aim = this.baseValue(Math.pow(this.difficultyAttributes.aimDifficulty, 0.8));
-        if (this.effectiveMissCount > 0) {
-            // Penalize misses by assessing # of misses relative to the total # of objects.
-            // Default a 3% reduction for any # of misses.
-            this.aim *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
-        }
-        // Combo scaling
-        this.aim *= this.comboPenalty;
+        let aimValue = this.baseValue(Math.pow(this.difficultyAttributes.aimDifficulty, 0.8));
+        aimValue *= Math.min(this.calculateStrainBasedMissPenalty(this.difficultyAttributes.aimDifficultStrainCount), this.proportionalMissPenalty);
+        // Scale the aim value with estimated full combo deviation.
+        aimValue *= this.calculateDeviationBasedLengthScaling();
         // Scale the aim value with slider factor to nerf very likely dropped sliderends.
-        this.aim *= this.sliderNerfFactor;
+        aimValue *= this.sliderNerfFactor;
         // Scale the aim value with slider cheese penalty.
-        this.aim *= this._aimSliderCheesePenalty;
+        aimValue *= this._aimSliderCheesePenalty;
         // Scale the aim value with deviation.
-        this.aim *=
-            1.05 *
-                Math.pow(osuBase.ErrorFunction.erf(32.0625 / (Math.SQRT2 * this._deviation)), 1.5);
+        aimValue *=
+            1.025 *
+                Math.pow(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._deviation)), 0.475);
+        // OD 7 SS stays the same.
+        aimValue *= 0.98 + Math.pow(7, 2) / 2500;
+        return aimValue;
     }
     /**
      * Calculates the tap performance value of the beatmap.
      */
     calculateTapValue() {
-        this.tap = this.baseValue(this.difficultyAttributes.tapDifficulty);
-        if (this.effectiveMissCount > 0) {
-            // Penalize misses by assessing # of misses relative to the total # of objects.
-            // Default a 3% reduction for any # of misses.
-            this.tap *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
-        }
-        // Combo scaling
-        this.tap *= this.comboPenalty;
+        let tapValue = this.baseValue(this.difficultyAttributes.tapDifficulty);
+        tapValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.tapDifficultStrainCount);
+        // Scale the tap value with estimated full combo deviation.
+        // Consider notes that are difficult to tap with respect to other notes, but
+        // also cap the note count to prevent buffing filler patterns.
+        tapValue *= this.calculateDeviationBasedLengthScaling(Math.min(this.difficultyAttributes.speedNoteCount, this.totalHits / 1.45));
+        // Normalize the deviation to 300 BPM.
+        const normalizedDeviation = this.tapDeviation *
+            Math.max(1, 50 / this.difficultyAttributes.averageSpeedDeltaTime);
+        // We expect the player to get 7500/x deviation when doubletapping x BPM.
+        // Using this expectation, we penalize scores with deviation above 25.
+        const averageBPM = 60000 / 4 / this.difficultyAttributes.averageSpeedDeltaTime;
+        const adjustedDeviation = normalizedDeviation *
+            (1 +
+                1 /
+                    (1 +
+                        Math.exp(-(normalizedDeviation - 7500 / averageBPM) /
+                            ((2 * 300) / averageBPM))));
         // Scale the tap value with tap deviation.
-        this.tap *=
-            1.1 *
-                Math.pow(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._tapDeviation)), 1.25);
+        tapValue *=
+            1.05 *
+                Math.pow(osuBase.ErrorFunction.erf(20 / (Math.SQRT2 * adjustedDeviation)), 0.6);
+        // Additional scaling for tap value based on average BPM and how "vibroable" the beatmap is.
+        // Higher BPMs require more precise tapping. When the deviation is too high,
+        // it can be assumed that the player taps invariant to rhythm.
+        // We harshen the punishment for such scenario.
+        tapValue *=
+            (1 - Math.pow(this.difficultyAttributes.vibroFactor, 6)) /
+                (1 +
+                    Math.exp((this._tapDeviation - 7500 / averageBPM) /
+                        ((2 * 300) / averageBPM))) +
+                Math.pow(this.difficultyAttributes.vibroFactor, 6);
         // Scale the tap value with three-fingered penalty.
-        this.tap /= this._tapPenalty;
+        tapValue /= this._tapPenalty;
+        // OD 8 SS stays the same.
+        tapValue *= 0.95 + Math.pow(8, 2) / 750;
+        return tapValue;
     }
     /**
      * Calculates the accuracy performance value of the beatmap.
@@ -2392,84 +2503,112 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
     calculateAccuracyValue() {
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax) ||
             this.totalSuccessfulHits === 0) {
-            this.accuracy = 0;
-            return;
+            return 0;
         }
-        this.accuracy =
-            650 *
-                Math.exp(-0.125 * this._deviation) *
-                // The following function is to give higher reward for deviations lower than 25 (250 UR).
-                (15 / (this._deviation + 15) + 0.65);
-        // Bonus for many hitcircles - it's harder to keep good accuracy up for longer.
+        let accuracyValue = 650 * Math.exp(-0.1 * this._deviation);
         const ncircles = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModScoreV2)
             ? this.totalHits - this.difficultyAttributes.spinnerCount
             : this.difficultyAttributes.hitCircleCount;
-        this.accuracy *= Math.min(1.15, Math.sqrt(Math.log(1 + ((Math.E - 1) * ncircles) / 1000)));
+        // Bonus for many hitcircles - it's harder to keep good accuracy up for longer.
+        accuracyValue *= Math.min(1.15, Math.sqrt(Math.log(1 + ((Math.E - 1) * ncircles) / 1000)));
         // Scale the accuracy value with rhythm complexity.
-        this.accuracy *=
+        accuracyValue *=
             1.5 /
                 (1 +
                     Math.exp(-(this.difficultyAttributes.rhythmDifficulty - 1) / 2));
+        // Penalize accuracy pp after the first miss.
+        accuracyValue *= Math.pow(0.97, Math.max(0, this.effectiveMissCount - 1));
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            this.accuracy *= 1.02;
+            accuracyValue *= 1.02;
         }
+        return accuracyValue;
     }
     /**
      * Calculates the flashlight performance value of the beatmap.
      */
     calculateFlashlightValue() {
         if (!this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            this.flashlight = 0;
-            return;
-        }
-        this.flashlight =
-            Math.pow(this.difficultyAttributes.flashlightDifficulty, 1.6) * 25;
-        // Combo scaling
-        this.flashlight *= this.comboPenalty;
-        if (this.effectiveMissCount > 0) {
-            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
-            this.flashlight *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+            return 0;
         }
+        let flashlightValue = Math.pow(this.difficultyAttributes.flashlightDifficulty, 1.6) * 25;
+        flashlightValue *= Math.min(this.calculateStrainBasedMissPenalty(this.difficultyAttributes.flashlightDifficultStrainCount), this.proportionalMissPenalty);
         // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
-        this.flashlight *=
+        flashlightValue *=
             0.7 +
                 0.1 * Math.min(1, this.totalHits / 200) +
                 (this.totalHits > 200
                     ? 0.2 * Math.min(1, (this.totalHits - 200) / 200)
                     : 0);
         // Scale the flashlight value with slider cheese penalty.
-        this.flashlight *= this._flashlightSliderCheesePenalty;
+        flashlightValue *= this._flashlightSliderCheesePenalty;
         // Scale the flashlight value with deviation.
-        this.flashlight *= osuBase.ErrorFunction.erf(50 / (Math.SQRT2 * this._deviation));
+        flashlightValue *= osuBase.ErrorFunction.erf(50 / (Math.SQRT2 * this._deviation));
+        return flashlightValue;
     }
     /**
      * Calculates the visual performance value of the beatmap.
      */
     calculateVisualValue() {
-        this.visual =
-            Math.pow(this.difficultyAttributes.visualDifficulty, 1.6) * 22.5;
-        if (this.effectiveMissCount > 0) {
-            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
-            this.visual *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
-        }
-        // Combo scaling
-        this.visual *= this.comboPenalty;
-        // Scale the visual value with object count to penalize short maps.
-        this.visual *= Math.min(1, 1.650668 +
-            (0.4845796 - 1.650668) /
-                (1 + Math.pow(this.totalHits / 817.9306, 1.147469)));
+        let visualValue = Math.pow(this.difficultyAttributes.visualDifficulty, 1.6) * 22.5;
+        visualValue *= Math.min(this.calculateStrainBasedMissPenalty(this.difficultyAttributes.visualDifficultStrainCount), this.proportionalMissPenalty);
+        // Scale the visual value with estimated full combo deviation.
+        // As visual is easily "bypassable" with memorization, punish for memorization.
+        visualValue *= this.calculateDeviationBasedLengthScaling(undefined, true);
         // Scale the visual value with slider cheese penalty.
-        this.visual *= this._visualSliderCheesePenalty;
+        visualValue *= this._visualSliderCheesePenalty;
         // Scale the visual value with deviation.
-        this.visual *=
-            1.065 *
-                Math.pow(osuBase.ErrorFunction.erf(30 / (Math.SQRT2 * this._deviation)), 1.75);
+        visualValue *=
+            1.05 *
+                Math.pow(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._deviation)), 0.775);
+        // OD 5 SS stays the same.
+        visualValue *= 0.98 + Math.pow(5, 2) / 2500;
+        return visualValue;
+    }
+    /**
+     * The object-based proportional miss penalty.
+     */
+    get proportionalMissPenalty() {
+        if (this.effectiveMissCount === 0) {
+            return 1;
+        }
+        const missProportion = (this.totalHits - this.effectiveMissCount) / (this.totalHits + 1);
+        const noMissProportion = this.totalHits / (this.totalHits + 1);
+        return (
+        // Aim deviation-based scale.
+        (osuBase.ErrorFunction.erfInv(missProportion) /
+            osuBase.ErrorFunction.erfInv(noMissProportion)) *
+            // Cheesing-based scale (i.e. 50% misses is deliberately only hitting each other
+            // note, 90% misses is deliberately only hitting 1 note every 10 notes).
+            Math.pow(missProportion, 8));
+    }
+    /**
+     * Calculates the object-based length scaling based on the deviation of a player for a full
+     * combo in this beatmap, taking retries into account.
+     *
+     * @param objectCount The amount of objects to be considered. Defaults to the amount of
+     * objects in this beatmap.
+     * @param punishForMemorization Whether to punish the deviation for memorization. Defaults to `false`.
+     */
+    calculateDeviationBasedLengthScaling(objectCount = this.totalHits, punishForMemorization = false) {
+        // Assume a sample proportion of hits for a full combo to be `(n - 0.5) / n` due to
+        // continuity correction, where `n` is the object count.
+        const calculateProportion = (notes) => (notes - 0.5) / notes;
+        // Keeping `x` notes as the benchmark, assume that a player will retry a beatmap
+        // `max(1, x/n)` times relative to an `x`-note beatmap.
+        const benchmarkNotes = 700;
+        // Calculate the proportion equivalent to the bottom half of retry count percentile of
+        // scores and take it as the player's "real" proportion.
+        const retryProportion = (proportion, notes, tries) => proportion +
+            Math.sqrt((2 * proportion * (1 - proportion)) / notes) *
+                osuBase.ErrorFunction.erfInv(1 / tries - 1);
+        // Using the proportion, we calculate the deviation based off that proportion and again
+        // compared to the hit deviation for proportion `(n - 0.5) / n`.
+        let multiplier = Math.max(0, osuBase.ErrorFunction.erfInv(retryProportion(calculateProportion(objectCount), objectCount, Math.max(1, benchmarkNotes / objectCount))) / osuBase.ErrorFunction.erfInv(calculateProportion(benchmarkNotes)) || 0);
+        // Punish for memorization if needed.
+        if (punishForMemorization) {
+            multiplier *= Math.min(1, Math.sqrt(objectCount / benchmarkNotes));
+        }
+        return multiplier;
     }
     /**
      * Estimates the player's tap deviation based on the OD, number of circles and sliders,
@@ -2490,40 +2629,65 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return Number.POSITIVE_INFINITY;
         }
         const hitWindow300 = new osuBase.OsuHitWindow(this.difficultyAttributes.overallDifficulty).hitWindowFor300();
-        // Obtain the 50 hit window for droid.
-        const clockRate = new osuBase.MapStats({
-            mods: this.difficultyAttributes.mods,
-        }).calculate().speedMultiplier;
-        const realHitWindow300 = hitWindow300 * clockRate;
-        const droidHitWindow = new osuBase.DroidHitWindow(osuBase.OsuHitWindow.hitWindow300ToOD(realHitWindow300));
-        const hitWindow50 = droidHitWindow.hitWindowFor50(this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise)) / clockRate;
-        const greatCountOnCircles = this.difficultyAttributes.hitCircleCount -
-            this.computedAccuracy.n100 -
-            this.computedAccuracy.n50 -
-            this.computedAccuracy.nmiss;
-        // 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 / bayesian prior.
-        const greatProbabilityCircle = Math.max(0, greatCountOnCircles / (this.difficultyAttributes.hitCircleCount + 1));
-        let greatProbabilitySlider;
-        if (greatCountOnCircles < 0) {
-            const nonCircleMisses = -greatCountOnCircles;
-            greatProbabilitySlider = Math.max(0, (this.difficultyAttributes.sliderCount - nonCircleMisses) /
-                (this.difficultyAttributes.sliderCount + 1));
-        }
-        else {
-            greatProbabilitySlider =
-                this.difficultyAttributes.sliderCount /
-                    (this.difficultyAttributes.sliderCount + 1);
-        }
-        if (greatProbabilityCircle === 0 && greatProbabilitySlider === 0) {
+        // Obtain the 50 and 100 hit window for droid.
+        const isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
+        const droidHitWindow = new osuBase.DroidHitWindow(osuBase.DroidHitWindow.hitWindow300ToOD(hitWindow300 * this.difficultyAttributes.clockRate, isPrecise));
+        const hitWindow50 = droidHitWindow.hitWindowFor50(isPrecise) /
+            this.difficultyAttributes.clockRate;
+        const hitWindow100 = droidHitWindow.hitWindowFor100(isPrecise) /
+            this.difficultyAttributes.clockRate;
+        const { n100, n50, nmiss } = this.computedAccuracy;
+        const circleCount = this.difficultyAttributes.hitCircleCount;
+        const missCountCircles = Math.min(nmiss, circleCount);
+        const mehCountCircles = Math.min(n50, circleCount - missCountCircles);
+        const okCountCircles = Math.min(n100, circleCount - missCountCircles - mehCountCircles);
+        const greatCountCircles = Math.max(0, circleCount - missCountCircles - mehCountCircles - okCountCircles);
+        // Assume 100s, 50s, and misses happen on circles. If there are less non-300s on circles than 300s,
+        // compute the deviation on circles.
+        if (greatCountCircles > 0) {
+            // 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 greatProbabilityCircle = greatCountCircles /
+                (circleCount - missCountCircles - mehCountCircles + 1);
+            // Compute the deviation assuming 300s and 100s are normally distributed, and 50s are uniformly distributed.
+            // Begin with the normal distribution first.
+            let deviationOnCircles = hitWindow300 /
+                (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilityCircle));
+            deviationOnCircles *= Math.sqrt(1 -
+                (Math.sqrt(2 / Math.PI) *
+                    hitWindow100 *
+                    Math.exp(-0.5 *
+                        Math.pow(hitWindow100 / deviationOnCircles, 2))) /
+                    (deviationOnCircles *
+                        osuBase.ErrorFunction.erf(hitWindow100 /
+                            (Math.SQRT2 * deviationOnCircles))));
+            // Then compute the variance for 50s.
+            const mehVariance = (hitWindow50 * hitWindow50 +
+                hitWindow100 * hitWindow50 +
+                hitWindow100 * hitWindow100) /
+                3;
+            // Find the total deviation.
+            deviationOnCircles = Math.sqrt(((greatCountCircles + okCountCircles) *
+                Math.pow(deviationOnCircles, 2) +
+                mehCountCircles * mehVariance) /
+                (greatCountCircles + okCountCircles + mehCountCircles));
+            return deviationOnCircles;
+        }
+        // If there are more non-300s than there are circles, compute the deviation on sliders instead.
+        // Here, all that matters is whether or not the slider was missed, since it is impossible
+        // to get a 100 or 50 on a slider by mis-tapping it.
+        const sliderCount = this.difficultyAttributes.sliderCount;
+        const missCountSliders = Math.min(sliderCount, nmiss - missCountCircles);
+        const greatCountSliders = sliderCount - missCountSliders;
+        // We only get here if nothing was hit. In this case, there is no estimate for deviation.
+        // Note that this is never negative, so checking if this is only equal to 0 makes sense.
+        if (greatCountSliders === 0) {
             return Number.POSITIVE_INFINITY;
         }
-        const deviationOnCircles = hitWindow300 /
-            (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilityCircle));
-        const deviationOnSliders = hitWindow50 /
-            (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilitySlider));
-        return Math.min(deviationOnCircles, deviationOnSliders);
+        const greatProbabilitySlider = greatCountSliders / (sliderCount + 1);
+        return (hitWindow50 /
+            (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilitySlider)));
     }
     /**
      * Does the same as {@link calculateDeviation}, but only for notes and inaccuracies that are relevant to tap difficulty.
@@ -2535,14 +2699,59 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (this.totalSuccessfulHits === 0) {
             return Number.POSITIVE_INFINITY;
         }
-        const hitWindow300 = new osuBase.OsuHitWindow(this.difficultyAttributes.overallDifficulty).hitWindowFor300();
-        const relevantTotalDiff = this.totalHits - this.difficultyAttributes.speedNoteCount;
-        const relevantCountGreat = Math.max(0, this.computedAccuracy.n300 - relevantTotalDiff);
-        if (relevantCountGreat === 0) {
-            return Number.POSITIVE_INFINITY;
-        }
-        const greatProbability = relevantCountGreat / (this.difficultyAttributes.speedNoteCount + 1);
-        return (hitWindow300 / (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbability)));
+        const { speedNoteCount, clockRate, overallDifficulty } = this.difficultyAttributes;
+        const hitWindow300 = new osuBase.OsuHitWindow(overallDifficulty).hitWindowFor300();
+        // Obtain the 50 and 100 hit window for droid.
+        const isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
+        const droidHitWindow = new osuBase.DroidHitWindow(osuBase.DroidHitWindow.hitWindow300ToOD(hitWindow300 * clockRate, isPrecise));
+        const hitWindow50 = droidHitWindow.hitWindowFor50(isPrecise) / clockRate;
+        const hitWindow100 = droidHitWindow.hitWindowFor100(isPrecise) / clockRate;
+        const { n100, n50, nmiss } = this.computedAccuracy;
+        // Assume a fixed ratio of non-300s hit in speed notes based on speed note count ratio and OD.
+        // Graph: https://www.desmos.com/calculator/iskvgjkxr4
+        const speedNoteRatio = speedNoteCount / this.totalHits;
+        const nonGreatCount = n100 + n50 + nmiss;
+        const nonGreatRatio = 1 -
+            (Math.pow(Math.exp(Math.sqrt(hitWindow300)) + 1, 1 - speedNoteRatio) -
+                1) /
+                Math.exp(Math.sqrt(hitWindow300));
+        const relevantCountGreat = Math.max(0, speedNoteCount - nonGreatCount * nonGreatRatio);
+        const relevantCountOk = n100 * nonGreatRatio;
+        const relevantCountMeh = n50 * nonGreatRatio;
+        const relevantCountMiss = nmiss * nonGreatRatio;
+        // Assume 100s, 50s, and misses happen on circles. If there are less non-300s on circles than 300s,
+        // compute the deviation on circles.
+        if (relevantCountGreat > 0) {
+            // 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 greatProbabilityCircle = relevantCountGreat /
+                (speedNoteCount - relevantCountMiss - relevantCountMeh + 1);
+            // Compute the deviation assuming 300s and 100s are normally distributed, and 50s are uniformly distributed.
+            // Begin with the normal distribution first.
+            let deviationOnCircles = hitWindow300 /
+                (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilityCircle));
+            deviationOnCircles *= Math.sqrt(1 -
+                (Math.sqrt(2 / Math.PI) *
+                    hitWindow100 *
+                    Math.exp(-0.5 *
+                        Math.pow(hitWindow100 / deviationOnCircles, 2))) /
+                    (deviationOnCircles *
+                        osuBase.ErrorFunction.erf(hitWindow100 /
+                            (Math.SQRT2 * deviationOnCircles))));
+            // Then compute the variance for 50s.
+            const mehVariance = (hitWindow50 * hitWindow50 +
+                hitWindow100 * hitWindow50 +
+                hitWindow100 * hitWindow100) /
+                3;
+            // Find the total deviation.
+            deviationOnCircles = Math.sqrt(((relevantCountGreat + relevantCountOk) *
+                Math.pow(deviationOnCircles, 2) +
+                relevantCountMeh * mehVariance) /
+                (relevantCountGreat + relevantCountOk + relevantCountMeh));
+            return deviationOnCircles;
+        }
+        return Number.POSITIVE_INFINITY;
     }
     toString() {
         return (this.total.toFixed(2) +
@@ -2565,20 +2774,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
  */
 class OsuSkill extends StrainSkill {
-    /**
-     * The default multiplier applied to the final difficulty value after all other calculations.
-     *
-     * May be overridden via {@link difficultyMultiplier}.
-     */
-    static defaultDifficultyMultiplier = 1.06;
-    /**
-     * The final multiplier to be applied to the final difficulty value after all other calculations.
-     */
-    difficultyMultiplier = OsuSkill.defaultDifficultyMultiplier;
     difficultyValue() {
-        const strains = this.strainPeaks
-            .slice()
-            .sort((a, b) => b - a);
+        const strains = this.strainPeaks.slice().sort((a, b) => b - a);
         if (this.reducedSectionCount > 0) {
             // We are reducing the highest strains first to account for extreme difficulty spikes.
             for (let i = 0; i < Math.min(strains.length, this.reducedSectionCount); ++i) {
@@ -2589,17 +2786,17 @@ class OsuSkill extends StrainSkill {
         }
         // Difficulty is the weighted sum of the highest strains from every section.
         // We're sorting from highest to lowest strain.
-        let difficulty = 0;
+        this.difficulty = 0;
         let weight = 1;
         for (const strain of strains) {
             const addition = strain * weight;
-            if (difficulty + addition === difficulty) {
+            if (this.difficulty + addition === this.difficulty) {
                 break;
             }
-            difficulty += addition;
+            this.difficulty += addition;
             weight *= this.decayWeight;
         }
-        return difficulty * this.difficultyMultiplier;
+        return this.difficulty;
     }
 }
 
@@ -2622,7 +2819,7 @@ class OsuAimEvaluator extends AimEvaluator {
         const last = current.previous(0);
         if (current.object instanceof osuBase.Spinner ||
             current.index <= 1 ||
-            last?.object instanceof osuBase.Spinner) {
+            (last === null || last === void 0 ? void 0 : last.object) instanceof osuBase.Spinner) {
             return 0;
         }
         const lastLast = current.previous(1);
@@ -2729,36 +2926,38 @@ class OsuAimEvaluator extends AimEvaluator {
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 class OsuAim extends OsuSkill {
-    skillMultiplier = 23.55;
-    strainDecayBase = 0.15;
-    reducedSectionCount = 10;
-    reducedSectionBaseline = 0.75;
-    difficultyMultiplier = 1.06;
-    decayWeight = 0.9;
-    withSliders;
     constructor(mods, withSliders) {
         super(mods);
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.decayWeight = 0.9;
+        this.currentAimStrain = 0;
+        this.skillMultiplier = 25.18;
         this.withSliders = withSliders;
     }
-    /**
-     * @param current The hitobject to calculate.
-     */
     strainValueAt(current) {
-        this.currentStrain *= this.strainDecay(current.deltaTime);
-        this.currentStrain +=
+        this.currentAimStrain *= this.strainDecay(current.deltaTime);
+        this.currentAimStrain +=
             OsuAimEvaluator.evaluateDifficultyOf(current, this.withSliders) *
                 this.skillMultiplier;
-        return this.currentStrain;
+        this._objectStrains.push(this.currentAimStrain);
+        return this.currentAimStrain;
+    }
+    calculateInitialStrain(time, current) {
+        var _a, _b;
+        return (this.currentAimStrain *
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
     /**
      * @param current The hitobject to save to.
      */
     saveToHitObject(current) {
         if (this.withSliders) {
-            current.aimStrainWithSliders = this.currentStrain;
+            current.aimStrainWithSliders = this.currentAimStrain;
         }
         else {
-            current.aimStrainWithoutSliders = this.currentStrain;
+            current.aimStrainWithoutSliders = this.currentAimStrain;
         }
     }
 }
@@ -2767,10 +2966,6 @@ class OsuAim extends OsuSkill {
  * An evaluator for calculating osu!standard speed skill.
  */
 class OsuSpeedEvaluator extends SpeedEvaluator {
-    /**
-     * Spacing threshold for a single hitobject spacing.
-     */
-    static SINGLE_SPACING_THRESHOLD = 125;
     /**
      * Evaluates the difficulty of tapping the current object, based on:
      *
@@ -2779,67 +2974,70 @@ class OsuSpeedEvaluator extends SpeedEvaluator {
      * - and how easily they can be cheesed.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current, greatWindow) {
+    static evaluateDifficultyOf(current) {
+        var _a;
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
         const prev = current.previous(0);
         let strainTime = current.strainTime;
-        const greatWindowFull = greatWindow * 2;
         // Nerf doubletappable doubles.
-        const next = current.next(0);
-        let doubletapness = 1;
-        if (next) {
-            const currentDeltaTime = Math.max(1, current.deltaTime);
-            const nextDeltaTime = Math.max(1, next.deltaTime);
-            const deltaDifference = Math.abs(nextDeltaTime - currentDeltaTime);
-            const speedRatio = currentDeltaTime / Math.max(currentDeltaTime, deltaDifference);
-            const windowRatio = Math.pow(Math.min(1, currentDeltaTime / greatWindowFull), 2);
-            doubletapness = Math.pow(speedRatio, 1 - windowRatio);
-        }
+        const doubletapness = 1 - current.doubletapness;
         // Cap deltatime to the OD 300 hitwindow.
         // 0.93 is derived from making sure 260 BPM 1/4 OD8 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.
-        strainTime /= osuBase.MathUtils.clamp(strainTime / greatWindowFull / 0.93, 0.92, 1);
-        let speedBonus = 1;
+        strainTime /= osuBase.MathUtils.clamp(strainTime / current.fullGreatWindow / 0.93, 0.92, 1);
+        // speedBonus will be 0.0 for BPM < 200
+        let speedBonus = 0;
+        // Add additional scaling bonus for streams/bursts higher than 200bpm
         if (strainTime < this.minSpeedBonus) {
-            speedBonus +=
+            speedBonus =
                 0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
         }
-        const travelDistance = prev?.travelDistance ?? 0;
+        const travelDistance = (_a = prev === null || prev === void 0 ? void 0 : prev.travelDistance) !== null && _a !== void 0 ? _a : 0;
+        // Cap distance at spacing threshold
         const distance = Math.min(this.SINGLE_SPACING_THRESHOLD, travelDistance + current.minimumJumpDistance);
-        return (((speedBonus +
-            speedBonus *
-                Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 3.5)) *
-            doubletapness) /
-            strainTime);
+        // Max distance bonus is 1 * `distance_multiplier` at single_spacing_threshold
+        const distanceBonus = Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 3.95) *
+            this.DISTANCE_MULTIPLIER;
+        // Base difficulty with all bonuses
+        const difficulty = ((1 + speedBonus + distanceBonus) * 1000) / strainTime;
+        // Apply penalty if there's doubletappable doubles
+        return difficulty * doubletapness;
     }
 }
+/**
+ * Spacing threshold for a single hitobject spacing.
+ *
+ * About 1.25 circles distance between hitobject centers.
+ */
+OsuSpeedEvaluator.SINGLE_SPACING_THRESHOLD = 125;
+OsuSpeedEvaluator.DISTANCE_MULTIPLIER = 0.94;
 
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
  */
-class OsuRhythmEvaluator extends RhythmEvaluator {
+class OsuRhythmEvaluator {
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current, greatWindow) {
+    static evaluateDifficultyOf(current) {
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
-        let previousIslandSize = 0;
+        const deltaDifferenceEpsilon = current.fullGreatWindow * 0.3;
         let rhythmComplexitySum = 0;
-        let islandSize = 1;
+        let island = new Island(deltaDifferenceEpsilon);
+        let previousIsland = new Island(deltaDifferenceEpsilon);
+        const islandCounts = new Map();
         // Store the ratio of the current start of an island to buff for tighter rhythms.
         let startRatio = 0;
         let firstDeltaSwitch = false;
-        const historicalNoteCount = Math.min(current.index, 32);
         let rhythmStart = 0;
+        const historicalNoteCount = Math.min(current.index, this.historyObjectsMax);
         while (rhythmStart < historicalNoteCount - 2 &&
             current.startTime - current.previous(rhythmStart).startTime <
                 this.historyTimeMax) {
@@ -2850,98 +3048,133 @@ class OsuRhythmEvaluator extends RhythmEvaluator {
             const prevObject = current.previous(i);
             const lastObject = current.previous(i + 1);
             // Scale note 0 to 1 from history to now.
-            let currentHistoricalDecay = (this.historyTimeMax -
+            const timeDecay = (this.historyTimeMax -
                 (current.startTime - currentObject.startTime)) /
                 this.historyTimeMax;
+            const noteDecay = (historicalNoteCount - i) / historicalNoteCount;
             // Either we're limited by time or limited by object count.
-            currentHistoricalDecay = Math.min(currentHistoricalDecay, (historicalNoteCount - i) / historicalNoteCount);
+            const currentHistoricalDecay = Math.min(timeDecay, noteDecay);
             const currentDelta = currentObject.strainTime;
             const prevDelta = prevObject.strainTime;
             const lastDelta = lastObject.strainTime;
+            // Calculate how much current delta difference deserves a rhythm bonus
+            // This function is meant to reduce rhythm bonus for deltas that are multiples of each other (i.e. 100 and 200)
+            const deltaDifferenceRatio = Math.min(prevDelta, currentDelta) /
+                Math.max(prevDelta, currentDelta);
             const currentRatio = 1 +
-                6 *
-                    Math.min(0.5, Math.pow(Math.sin(Math.PI /
-                        (Math.min(prevDelta, currentDelta) /
-                            Math.max(prevDelta, currentDelta))), 2));
-            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - greatWindow * 0.6) /
-                (greatWindow * 0.6));
-            let effectiveRatio = windowPenalty * currentRatio;
+                this.rhythmRatioMultiplier *
+                    Math.min(0.5, Math.pow(Math.sin(Math.PI / deltaDifferenceRatio), 2));
+            // Reduce ratio bonus if delta difference is too big
+            const fraction = Math.max(prevDelta / currentDelta, currentDelta / prevDelta);
+            const fractionMultiplier = osuBase.MathUtils.clamp(2 - fraction / 8, 0, 1);
+            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - deltaDifferenceEpsilon) / deltaDifferenceEpsilon);
+            let effectiveRatio = windowPenalty * currentRatio * fractionMultiplier;
             if (firstDeltaSwitch) {
-                if (prevDelta <= 1.25 * currentDelta &&
-                    prevDelta * 1.25 >= currentDelta) {
+                if (Math.abs(prevDelta - currentDelta) < deltaDifferenceEpsilon) {
                     // Island is still progressing, count size.
-                    if (islandSize < 7) {
-                        ++islandSize;
-                    }
+                    island.addDelta(currentDelta);
                 }
                 else {
+                    // BPM change is into slider, this is easy acc window.
                     if (currentObject.object instanceof osuBase.Slider) {
-                        // BPM change is into slider, this is easy acc window.
                         effectiveRatio /= 8;
                     }
+                    // BPM change was from a slider, this is easier typically than circle -> circle.
+                    // Unintentional side effect is that bursts with kicksliders at the ends might have lower difficulty
+                    // than bursts without sliders.
                     if (prevObject.object instanceof osuBase.Slider) {
-                        // BPM change was from a slider, this is typically easier than circle -> circle.
-                        effectiveRatio /= 4;
-                    }
-                    if (previousIslandSize === islandSize) {
-                        // Repeated island size (ex: triplet -> triplet).
-                        effectiveRatio /= 4;
+                        effectiveRatio *= 0.3;
                     }
-                    if (previousIslandSize % 2 === islandSize % 2) {
-                        // Repeated island polarity (2 -> 4, 3 -> 5).
+                    // Repeated island polarity (2 -> 4, 3 -> 5).
+                    if (island.isSimilarPolarity(previousIsland)) {
                         effectiveRatio /= 2;
                     }
-                    if (lastDelta > prevDelta + 10 &&
-                        prevDelta > currentDelta + 10) {
-                        // Previous increase happened a note ago.
-                        // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                    // Previous increase happened a note ago.
+                    // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                    if (lastDelta > prevDelta + deltaDifferenceEpsilon &&
+                        prevDelta > currentDelta + deltaDifferenceEpsilon) {
                         effectiveRatio /= 8;
                     }
+                    // Repeated island size (ex: triplet -> triplet).
+                    // TODO: remove this nerf since its staying here only for balancing purposes because of the flawed ratio calculation
+                    if (previousIsland.deltaCount == island.deltaCount) {
+                        effectiveRatio /= 2;
+                    }
+                    let islandFound = false;
+                    for (const [currentIsland, count] of islandCounts) {
+                        if (!island.equals(currentIsland)) {
+                            continue;
+                        }
+                        islandFound = true;
+                        let islandCount = count;
+                        if (previousIsland.equals(island)) {
+                            // Only add island to island counts if they're going one after another.
+                            ++islandCount;
+                            islandCounts.set(currentIsland, islandCount);
+                        }
+                        // 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))));
+                        break;
+                    }
+                    if (!islandFound) {
+                        islandCounts.set(island, 1);
+                    }
+                    // Scale down the difficulty if the object is doubletappable.
+                    effectiveRatio *= 1 - prevObject.doubletapness * 0.75;
                     rhythmComplexitySum +=
-                        (((Math.sqrt(effectiveRatio * startRatio) *
-                            currentHistoricalDecay *
-                            Math.sqrt(4 + islandSize)) /
-                            2) *
-                            Math.sqrt(4 + previousIslandSize)) /
-                            2;
+                        Math.sqrt(effectiveRatio * startRatio) *
+                            currentHistoricalDecay;
                     startRatio = effectiveRatio;
-                    previousIslandSize = islandSize;
-                    if (prevDelta * 1.25 < currentDelta) {
+                    previousIsland = island;
+                    if (prevDelta + deltaDifferenceEpsilon < currentDelta) {
                         // We're slowing down, stop counting.
                         // If we're speeding up, this stays as is and we keep counting island size.
                         firstDeltaSwitch = false;
                     }
-                    islandSize = 1;
+                    island = new Island(currentDelta, deltaDifferenceEpsilon);
                 }
             }
-            else if (prevDelta > 1.25 * currentDelta) {
-                // We want to be speeding up.
+            else if (prevDelta > currentDelta + deltaDifferenceEpsilon) {
+                // We are speeding up.
                 // Begin counting island until we change speed again.
                 firstDeltaSwitch = true;
+                // BPM change is into slider, this is easy acc window.
+                if (currentObject.object instanceof osuBase.Slider) {
+                    effectiveRatio *= 0.6;
+                }
+                // BPM change was from a slider, this is easier typically than circle -> circle
+                // Unintentional side effect is that bursts with kicksliders at the ends might have lower difficulty
+                // than bursts without sliders
+                if (prevObject.object instanceof osuBase.Slider) {
+                    effectiveRatio *= 0.6;
+                }
                 startRatio = effectiveRatio;
-                islandSize = 1;
+                island = new Island(currentDelta, deltaDifferenceEpsilon);
             }
         }
-        return Math.sqrt(4 + rhythmComplexitySum * this.rhythmMultiplier) / 2;
+        return (Math.sqrt(4 + rhythmComplexitySum * this.rhythmOverallMultiplier) /
+            2);
     }
 }
+OsuRhythmEvaluator.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
+OsuRhythmEvaluator.historyObjectsMax = 32;
+OsuRhythmEvaluator.rhythmOverallMultiplier = 0.95;
+OsuRhythmEvaluator.rhythmRatioMultiplier = 12;
 
 /**
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 class OsuSpeed extends OsuSkill {
-    skillMultiplier = 1375;
-    strainDecayBase = 0.3;
-    reducedSectionCount = 5;
-    reducedSectionBaseline = 0.75;
-    difficultyMultiplier = 1.04;
-    decayWeight = 0.9;
-    currentSpeedStrain = 0;
-    currentRhythm = 0;
-    greatWindow;
-    constructor(mods, greatWindow) {
-        super(mods);
-        this.greatWindow = greatWindow;
+    constructor() {
+        super(...arguments);
+        this.strainDecayBase = 0.3;
+        this.reducedSectionCount = 5;
+        this.reducedSectionBaseline = 0.75;
+        this.decayWeight = 0.9;
+        this.currentSpeedStrain = 0;
+        this.currentRhythm = 0;
+        this.skillMultiplier = 1.43;
     }
     /**
      * @param current The hitobject to calculate.
@@ -2949,16 +3182,24 @@ class OsuSpeed extends OsuSkill {
     strainValueAt(current) {
         this.currentSpeedStrain *= this.strainDecay(current.strainTime);
         this.currentSpeedStrain +=
-            OsuSpeedEvaluator.evaluateDifficultyOf(current, this.greatWindow) *
+            OsuSpeedEvaluator.evaluateDifficultyOf(current) *
                 this.skillMultiplier;
-        this.currentRhythm = OsuRhythmEvaluator.evaluateDifficultyOf(current, this.greatWindow);
-        return this.currentSpeedStrain * this.currentRhythm;
+        this.currentRhythm = OsuRhythmEvaluator.evaluateDifficultyOf(current);
+        const strain = this.currentSpeedStrain * this.currentRhythm;
+        this._objectStrains.push(strain);
+        return strain;
+    }
+    calculateInitialStrain(time, current) {
+        var _a, _b;
+        return (this.currentSpeedStrain *
+            this.currentRhythm *
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
     /**
      * @param current The hitobject to save to.
      */
     saveToHitObject(current) {
-        current.tapStrain = this.currentStrain;
+        current.speedStrain = this.currentSpeedStrain * this.currentRhythm;
         current.rhythmMultiplier = this.currentRhythm;
     }
 }
@@ -2983,7 +3224,7 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
-        const scalingFactor = 52 / current.object.getRadius(osuBase.Modes.osu);
+        const scalingFactor = 52 / current.object.radius;
         let smallDistNerf = 1;
         let cumulativeStrainTime = 0;
         let result = 0;
@@ -2994,7 +3235,7 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
             if (!(currentObject.object instanceof osuBase.Spinner)) {
                 const jumpDistance = current.object
                     .getStackedPosition(osuBase.Modes.osu)
-                    .subtract(currentObject.object.endPosition).length;
+                    .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) {
@@ -3006,7 +3247,7 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
                 const opacityBonus = 1 +
                     this.maxOpacityBonus *
                         (1 -
-                            current.opacityAt(currentObject.object.startTime, isHiddenMod, osuBase.Modes.osu));
+                            current.opacityAt(currentObject.object.startTime, isHiddenMod));
                 result +=
                     (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
                         cumulativeStrainTime;
@@ -3037,8 +3278,8 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
             // Longer sliders require more memorization.
             sliderBonus *= pixelTravelDistance;
             // Nerf sliders with repeats, as less memorization is required.
-            if (current.object.repeats > 0)
-                sliderBonus /= current.object.repeats + 1;
+            if (current.object.repeatCount > 0)
+                sliderBonus /= current.object.repeatCount + 1;
         }
         result += sliderBonus * this.sliderMultiplier;
         return result;
@@ -3049,27 +3290,62 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 class OsuFlashlight extends OsuSkill {
-    skillMultiplier = 0.052;
-    strainDecayBase = 0.15;
-    reducedSectionCount = 0;
-    reducedSectionBaseline = 1;
-    decayWeight = 1;
-    isHidden;
     constructor(mods) {
         super(mods);
+        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);
     }
-    /**
-     * @param current The hitobject to calculate.
-     */
+    difficultyValue() {
+        return this.strainPeaks.reduce((a, b) => a + b, 0);
+    }
     strainValueAt(current) {
-        this.currentStrain *= this.strainDecay(current.deltaTime);
-        this.currentStrain +=
+        this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
+        this.currentFlashlightStrain +=
             OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.isHidden) * this.skillMultiplier;
-        return this.currentStrain;
+        return this.currentFlashlightStrain;
+    }
+    calculateInitialStrain(time, current) {
+        var _a, _b;
+        return (this.currentFlashlightStrain *
+            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
     saveToHitObject(current) {
-        current.flashlightStrainWithSliders = this.currentStrain;
+        current.flashlightStrain = this.currentFlashlightStrain;
+    }
+}
+
+/**
+ * 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 = this.normalizedRadius / radius;
+        // High circle size (small CS) bonus
+        if (radius < this.radiusBuffThreshold) {
+            scalingFactor *=
+                1 + Math.min(this.radiusBuffThreshold - radius, 5) / 50;
+        }
+        return scalingFactor;
     }
 }
 
@@ -3077,35 +3353,50 @@ class OsuFlashlight extends OsuSkill {
  * A difficulty calculator for osu!standard gamemode.
  */
 class OsuDifficultyCalculator extends DifficultyCalculator {
+    constructor() {
+        super(...arguments);
+        this.attributes = {
+            speedDifficulty: 0,
+            mods: [],
+            starRating: 0,
+            maxCombo: 0,
+            aimDifficulty: 0,
+            flashlightDifficulty: 0,
+            speedNoteCount: 0,
+            sliderFactor: 0,
+            clockRate: 1,
+            approachRate: 0,
+            overallDifficulty: 0,
+            hitCircleCount: 0,
+            sliderCount: 0,
+            spinnerCount: 0,
+            aimDifficultStrainCount: 0,
+            speedDifficultStrainCount: 0,
+        };
+        this.difficultyMultiplier = 0.0675;
+        this.mode = osuBase.Modes.osu;
+    }
     /**
      * The aim star rating of the beatmap.
      */
-    aim = 0;
+    get aim() {
+        return this.attributes.aimDifficulty;
+    }
     /**
      * The speed star rating of the beatmap.
      */
-    speed = 0;
+    get speed() {
+        return this.attributes.speedDifficulty;
+    }
     /**
      * The flashlight star rating of the beatmap.
      */
-    flashlight = 0;
-    attributes = {
-        speedDifficulty: 0,
-        mods: [],
-        starRating: 0,
-        maxCombo: 0,
-        aimDifficulty: 0,
-        flashlightDifficulty: 0,
-        speedNoteCount: 0,
-        sliderFactor: 0,
-        approachRate: 0,
-        overallDifficulty: 0,
-        hitCircleCount: 0,
-        sliderCount: 0,
-        spinnerCount: 0,
-    };
-    difficultyMultiplier = 0.0675;
-    mode = osuBase.Modes.osu;
+    get flashlight() {
+        return this.attributes.flashlightDifficulty;
+    }
+    get cacheableAttributes() {
+        return Object.assign(Object.assign({}, this.attributes), { mods: osuBase.ModUtil.modsToOsuString(this.attributes.mods) });
+    }
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -3120,10 +3411,10 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
      */
     calculateSpeed() {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.speed = this.attributes.speedDifficulty = 0;
+            this.attributes.speedDifficulty = 0;
             return;
         }
-        const speedSkill = new OsuSpeed(this.mods, new osuBase.OsuHitWindow(this.stats.od).hitWindowFor300());
+        const speedSkill = new OsuSpeed(this.mods);
         this.calculateSkills(speedSkill);
         this.postCalculateSpeed(speedSkill);
     }
@@ -3148,14 +3439,14 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         if (basePerformanceValue > 1e-5) {
             // Document for formula derivation:
             // https://docs.google.com/document/d/10DZGYYSsT_yjz2Mtp6yIJld0Rqx4E-vVHupCqiM4TNI/edit
-            this.total = this.attributes.starRating =
-                Math.cbrt(1.14) *
+            this.attributes.starRating =
+                Math.cbrt(1.15) *
                     0.027 *
                     (Math.cbrt((100000 / Math.pow(2, 1 / 1.1)) * basePerformanceValue) +
                         4);
         }
         else {
-            this.total = this.attributes.starRating = 0;
+            this.attributes.starRating = 0;
         }
     }
     calculateAll() {
@@ -3168,7 +3459,6 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         const flashlightSkill = skills[3];
         this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
         if (isRelax) {
-            this.speed = 0;
             this.attributes.speedDifficulty = 0;
         }
         else {
@@ -3178,9 +3468,6 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         this.postCalculateFlashlight(flashlightSkill);
         this.calculateTotal();
     }
-    /**
-     * Returns a string representative of the class.
-     */
     toString() {
         return (this.total.toFixed(2) +
             " stars (" +
@@ -3191,17 +3478,32 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             this.flashlight.toFixed(2) +
             " flashlight)");
     }
-    /**
-     * Creates skills to be calculated.
-     */
+    generateDifficultyHitObjects(beatmap, clockRate) {
+        var _a, _b;
+        const difficultyObjects = [];
+        const { objects } = beatmap.hitObjects;
+        const greatWindow = new osuBase.OsuHitWindow(beatmap.difficulty.od).hitWindowFor300() /
+            clockRate;
+        for (let i = 0; i < objects.length; ++i) {
+            const difficultyObject = new OsuDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, (_b = objects[i - 2]) !== null && _b !== void 0 ? _b : null, difficultyObjects, clockRate, greatWindow);
+            difficultyObject.computeProperties(clockRate, objects);
+            difficultyObjects.push(difficultyObject);
+        }
+        return difficultyObjects;
+    }
     createSkills() {
         return [
             new OsuAim(this.mods, true),
             new OsuAim(this.mods, false),
-            new OsuSpeed(this.mods, new osuBase.OsuHitWindow(this.stats.od).hitWindowFor300()),
+            new OsuSpeed(this.mods),
             new OsuFlashlight(this.mods),
         ];
     }
+    populateDifficultyAttributes(beatmap, clockRate) {
+        super.populateDifficultyAttributes(beatmap, clockRate);
+        const preempt = osuBase.BeatmapDifficulty.difficultyRange(beatmap.difficulty.ar, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin) / clockRate;
+        this.attributes.approachRate = osuBase.BeatmapDifficulty.inverseDifficultyRange(preempt, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin);
+    }
     /**
      * Called after aim skill calculation.
      *
@@ -3211,19 +3513,20 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
     postCalculateAim(aimSkill, aimSkillWithoutSliders) {
         this.strainPeaks.aimWithSliders = aimSkill.strainPeaks;
         this.strainPeaks.aimWithoutSliders = aimSkillWithoutSliders.strainPeaks;
-        this.aim = this.starValue(aimSkill.difficultyValue());
+        this.attributes.aimDifficulty = this.starValue(aimSkill.difficultyValue());
         if (this.aim) {
             this.attributes.sliderFactor =
                 this.starValue(aimSkillWithoutSliders.difficultyValue()) /
                     this.aim;
         }
         if (this.mods.some((m) => m instanceof osuBase.ModTouchDevice)) {
-            this.aim = Math.pow(this.aim, 0.8);
+            this.attributes.aimDifficulty = Math.pow(this.aim, 0.8);
         }
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.aim *= 0.9;
+            this.attributes.aimDifficulty *= 0.9;
         }
-        this.attributes.aimDifficulty = this.aim;
+        this.attributes.aimDifficultStrainCount =
+            aimSkill.countDifficultStrains();
     }
     /**
      * Called after speed skill calculation.
@@ -3232,13 +3535,15 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
      */
     postCalculateSpeed(speedSkill) {
         this.strainPeaks.speed = speedSkill.strainPeaks;
-        this.speed = this.attributes.speedDifficulty = this.starValue(speedSkill.difficultyValue());
+        this.attributes.speedDifficulty = this.starValue(speedSkill.difficultyValue());
+        this.attributes.speedDifficultStrainCount =
+            speedSkill.countDifficultStrains();
     }
     /**
      * Calculates speed-related attributes.
      */
     calculateSpeedAttributes() {
-        const objectStrains = this.objects.map((v) => v.tapStrain);
+        const objectStrains = this.objects.map((v) => v.speedStrain);
         const maxStrain = Math.max(...objectStrains);
         if (maxStrain) {
             this.attributes.speedNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
@@ -3251,55 +3556,13 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
      */
     postCalculateFlashlight(flashlightSkill) {
         this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
-        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+        this.attributes.flashlightDifficulty = this.starValue(flashlightSkill.difficultyValue());
         if (this.mods.some((m) => m instanceof osuBase.ModTouchDevice)) {
-            this.flashlight = Math.pow(this.flashlight, 0.8);
+            this.attributes.flashlightDifficulty = Math.pow(this.flashlight, 0.8);
         }
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.flashlight *= 0.7;
+            this.attributes.flashlightDifficulty *= 0.7;
         }
-        this.attributes.flashlightDifficulty = this.flashlight;
-    }
-}
-
-/**
- * A difficulty calculator that calculates for both osu!droid and osu!standard gamemode.
- */
-class MapStars {
-    /**
-     * The osu!droid difficulty calculator of the beatmap.
-     */
-    droid;
-    /**
-     * The osu!standard difficulty calculator of the beatmap.
-     */
-    osu;
-    /**
-     * Constructs this instance and calculates the given beatmap's osu!droid and osu!standard difficulty.
-     *
-     * @param beatmap The beatmap to calculate.
-     * @param options Options for the difficulty calculation.
-     */
-    constructor(beatmap, options) {
-        const stats = new osuBase.MapStats({
-            speedMultiplier: options?.stats?.speedMultiplier ?? 1,
-            isForceAR: options?.stats?.isForceAR ?? false,
-            oldStatistics: options?.stats?.oldStatistics ?? false,
-        });
-        this.droid = new DroidDifficultyCalculator(beatmap).calculate({
-            ...options,
-            stats,
-        });
-        this.osu = new OsuDifficultyCalculator(beatmap).calculate({
-            ...options,
-            stats,
-        });
-    }
-    /**
-     * Returns a string representative of the class.
-     */
-    toString() {
-        return `${this.droid.toString()}\n${this.osu.toString()}`;
     }
 }
 
@@ -3307,65 +3570,60 @@ class MapStars {
  * A performance points calculator that calculates performance points for osu!standard gamemode.
  */
 class OsuPerformanceCalculator extends PerformanceCalculator {
-    /**
-     * The aim performance value.
-     */
-    aim = 0;
-    /**
-     * The speed performance value.
-     */
-    speed = 0;
-    /**
-     * The accuracy performance value.
-     */
-    accuracy = 0;
-    /**
-     * The flashlight performance value.
-     */
-    flashlight = 0;
-    difficultyAttributes;
-    finalMultiplier = 1.14;
-    mode = osuBase.Modes.osu;
-    /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
-     */
-    constructor(difficultyAttributes) {
-        super();
-        this.difficultyAttributes = osuBase.Utils.deepCopy(difficultyAttributes);
+    constructor() {
+        super(...arguments);
+        /**
+         * The aim performance value.
+         */
+        this.aim = 0;
+        /**
+         * The speed performance value.
+         */
+        this.speed = 0;
+        /**
+         * The accuracy performance value.
+         */
+        this.accuracy = 0;
+        /**
+         * The flashlight performance value.
+         */
+        this.flashlight = 0;
+        this.finalMultiplier = 1.15;
+        this.mode = osuBase.Modes.osu;
+        this.comboPenalty = 1;
     }
     calculateValues() {
-        this.calculateAimValue();
-        this.calculateSpeedValue();
-        this.calculateAccuracyValue();
-        this.calculateFlashlightValue();
+        this.aim = this.calculateAimValue();
+        this.speed = this.calculateSpeedValue();
+        this.accuracy = this.calculateAccuracyValue();
+        this.flashlight = this.calculateFlashlightValue();
     }
     calculateTotalValue() {
-        this.total =
-            Math.pow(Math.pow(this.aim, 1.1) +
-                Math.pow(this.speed, 1.1) +
-                Math.pow(this.accuracy, 1.1) +
-                Math.pow(this.flashlight, 1.1), 1 / 1.1) * this.finalMultiplier;
+        return (Math.pow(Math.pow(this.aim, 1.1) +
+            Math.pow(this.speed, 1.1) +
+            Math.pow(this.accuracy, 1.1) +
+            Math.pow(this.flashlight, 1.1), 1 / 1.1) * this.finalMultiplier);
+    }
+    handleOptions(options) {
+        var _a;
+        super.handleOptions(options);
+        const maxCombo = this.difficultyAttributes.maxCombo;
+        const miss = this.computedAccuracy.nmiss;
+        const combo = (_a = options === null || options === void 0 ? void 0 : options.combo) !== null && _a !== void 0 ? _a : maxCombo - miss;
+        this.comboPenalty = Math.min(Math.pow(combo / maxCombo, 0.8), 1);
     }
     /**
      * Calculates the aim performance value of the beatmap.
      */
     calculateAimValue() {
-        this.aim = this.baseValue(this.difficultyAttributes.aimDifficulty);
+        let aimValue = this.baseValue(this.difficultyAttributes.aimDifficulty);
         // Longer maps are worth more
         let lengthBonus = 0.95 + 0.4 * Math.min(1, this.totalHits / 2000);
         if (this.totalHits > 2000) {
             lengthBonus += Math.log10(this.totalHits / 2000) * 0.5;
         }
-        this.aim *= 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.
-            this.aim *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
-        }
-        // Combo scaling
-        this.aim *= this.comboPenalty;
+        aimValue *= lengthBonus;
+        aimValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.aimDifficultStrainCount);
         const calculatedAR = this.difficultyAttributes.approachRate;
         if (!this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
             // AR scaling
@@ -3377,145 +3635,131 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                 arFactor += 0.05 * (8 - calculatedAR);
             }
             // Buff for longer maps with high AR.
-            this.aim *= 1 + arFactor * lengthBonus;
+            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.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHidden)) {
-            this.aim *= 1 + 0.04 * (12 - calculatedAR);
+            aimValue *= 1 + 0.04 * (12 - calculatedAR);
         }
         // Scale the aim value with slider factor to nerf very likely dropped sliderends.
-        this.aim *= this.sliderNerfFactor;
+        aimValue *= this.sliderNerfFactor;
         // Scale the aim value with accuracy.
-        this.aim *= this.computedAccuracy.value(this.totalHits);
+        aimValue *= this.computedAccuracy.value();
         // It is also important to consider accuracy difficulty when doing that.
         const odScaling = Math.pow(this.difficultyAttributes.overallDifficulty, 2) / 2500;
-        this.aim *= 0.98 + odScaling;
+        aimValue *= 0.98 + odScaling;
+        return aimValue;
     }
     /**
      * Calculates the speed performance value of the beatmap.
      */
     calculateSpeedValue() {
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.speed = 0;
-            return;
+            return 0;
         }
-        // Global variables
-        this.speed = this.baseValue(this.difficultyAttributes.speedDifficulty);
+        let speedValue = this.baseValue(this.difficultyAttributes.speedDifficulty);
         // Longer maps are worth more
         let lengthBonus = 0.95 + 0.4 * Math.min(1, this.totalHits / 2000);
         if (this.totalHits > 2000) {
             lengthBonus += Math.log10(this.totalHits / 2000) * 0.5;
         }
-        this.speed *= 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.
-            this.speed *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
-        }
-        // Combo scaling
-        this.speed *= this.comboPenalty;
+        speedValue *= lengthBonus;
+        speedValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.speedDifficultStrainCount);
         // AR scaling
         const calculatedAR = this.difficultyAttributes.approachRate;
         if (calculatedAR > 10.33) {
             // Buff for longer maps with high AR.
-            this.speed *= 1 + 0.3 * (calculatedAR - 10.33) * lengthBonus;
+            speedValue *= 1 + 0.3 * (calculatedAR - 10.33) * lengthBonus;
         }
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHidden)) {
-            this.speed *= 1 + 0.04 * (12 - calculatedAR);
+            speedValue *= 1 + 0.04 * (12 - calculatedAR);
         }
         // Calculate accuracy assuming the worst case scenario.
         const countGreat = this.computedAccuracy.n300;
         const countOk = this.computedAccuracy.n100;
         const countMeh = this.computedAccuracy.n50;
         const relevantTotalDiff = this.totalHits - this.difficultyAttributes.speedNoteCount;
-        const relevantAccuracy = new osuBase.Accuracy({
-            n300: Math.max(0, countGreat - relevantTotalDiff),
-            n100: Math.max(0, countOk - Math.max(0, relevantTotalDiff - countGreat)),
-            n50: Math.max(0, countMeh - Math.max(0, relevantTotalDiff - countGreat - countOk)),
-            nmiss: this.effectiveMissCount,
-        });
+        const relevantAccuracy = new osuBase.Accuracy(this.difficultyAttributes.speedNoteCount > 0
+            ? {
+                n300: Math.max(0, countGreat - relevantTotalDiff),
+                n100: Math.max(0, countOk - Math.max(0, relevantTotalDiff - countGreat)),
+                n50: Math.max(0, countMeh -
+                    Math.max(0, relevantTotalDiff - countGreat - countOk)),
+            }
+            : // Set accuracy to 0.
+                { n300: 0, nobjects: 1 });
         // Scale the speed value with accuracy and OD.
-        this.speed *=
+        speedValue *=
             (0.95 +
                 Math.pow(this.difficultyAttributes.overallDifficulty, 2) /
                     750) *
-                Math.pow((this.computedAccuracy.value(this.totalHits) +
-                    relevantAccuracy.value()) /
-                    2, (14.5 -
-                    Math.max(this.difficultyAttributes.overallDifficulty, 8)) /
-                    2);
+                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.
-        this.speed *= Math.pow(0.99, Math.max(0, this.computedAccuracy.n50 - this.totalHits / 500));
+        speedValue *= Math.pow(0.99, Math.max(0, this.computedAccuracy.n50 - this.totalHits / 500));
+        return speedValue;
     }
     /**
      * Calculates the accuracy performance value of the beatmap.
      */
     calculateAccuracyValue() {
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.accuracy = 0;
-            return;
+            return 0;
         }
         const ncircles = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModScoreV2)
             ? this.totalHits - this.difficultyAttributes.spinnerCount
             : this.difficultyAttributes.hitCircleCount;
         if (ncircles === 0) {
-            this.accuracy = 0;
-            return;
+            return 0;
         }
-        const realAccuracy = new osuBase.Accuracy({
-            ...this.computedAccuracy,
-            n300: this.computedAccuracy.n300 - (this.totalHits - ncircles),
-        });
+        const realAccuracy = new osuBase.Accuracy(Object.assign(Object.assign({}, this.computedAccuracy), { n300: this.computedAccuracy.n300 - (this.totalHits - ncircles) }));
         // Lots of arbitrary values from testing.
         // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
-        this.accuracy =
-            Math.pow(1.52163, this.difficultyAttributes.overallDifficulty) *
-                Math.pow(realAccuracy.value(ncircles), 24) *
-                2.83;
+        let accuracyValue = Math.pow(1.52163, this.difficultyAttributes.overallDifficulty) *
+            // It is possible to reach a negative accuracy with this formula. Cap it at zero - zero points.
+            Math.pow(realAccuracy.n300 < 0 ? 0 : realAccuracy.value(), 24) *
+            2.83;
         // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
-        this.accuracy *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
+        accuracyValue *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHidden)) {
-            this.accuracy *= 1.08;
+            accuracyValue *= 1.08;
         }
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            this.accuracy *= 1.02;
+            accuracyValue *= 1.02;
         }
+        return accuracyValue;
     }
     /**
      * Calculates the flashlight performance value of the beatmap.
      */
     calculateFlashlightValue() {
         if (!this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            this.flashlight = 0;
-            return;
+            return 0;
         }
-        // Global variables
-        this.flashlight =
-            Math.pow(this.difficultyAttributes.flashlightDifficulty, 2) * 25;
+        let flashlightValue = Math.pow(this.difficultyAttributes.flashlightDifficulty, 2) * 25;
         // Combo scaling
-        this.flashlight *= this.comboPenalty;
+        flashlightValue *= this.comboPenalty;
         if (this.effectiveMissCount > 0) {
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
-            this.flashlight *=
+            flashlightValue *=
                 0.97 *
                     Math.pow(1 -
                         Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
         }
         // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
-        this.flashlight *=
+        flashlightValue *=
             0.7 +
                 0.1 * Math.min(1, this.totalHits / 200) +
                 (this.totalHits > 200
                     ? 0.2 * Math.min(1, (this.totalHits - 200) / 200)
                     : 0);
         // Scale the flashlight value with accuracy slightly.
-        this.flashlight *=
-            0.5 + this.computedAccuracy.value(this.totalHits) / 2;
+        flashlightValue *= 0.5 + this.computedAccuracy.value() / 2;
         // It is also important to consider accuracy difficulty when doing that.
         const odScaling = Math.pow(this.difficultyAttributes.overallDifficulty, 2) / 2500;
-        this.flashlight *= 0.98 + odScaling;
+        flashlightValue *= 0.98 + odScaling;
+        return flashlightValue;
     }
     toString() {
         return (this.total.toFixed(2) +
@@ -3534,10 +3778,10 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
 exports.AimEvaluator = AimEvaluator;
 exports.DifficultyCalculator = DifficultyCalculator;
 exports.DifficultyHitObject = DifficultyHitObject;
-exports.DifficultyHitObjectCreator = DifficultyHitObjectCreator;
 exports.DroidAim = DroidAim;
 exports.DroidAimEvaluator = DroidAimEvaluator;
 exports.DroidDifficultyCalculator = DroidDifficultyCalculator;
+exports.DroidDifficultyHitObject = DroidDifficultyHitObject;
 exports.DroidFlashlight = DroidFlashlight;
 exports.DroidFlashlightEvaluator = DroidFlashlightEvaluator;
 exports.DroidPerformanceCalculator = DroidPerformanceCalculator;
@@ -3548,10 +3792,10 @@ exports.DroidTapEvaluator = DroidTapEvaluator;
 exports.DroidVisual = DroidVisual;
 exports.DroidVisualEvaluator = DroidVisualEvaluator;
 exports.FlashlightEvaluator = FlashlightEvaluator;
-exports.MapStars = MapStars;
 exports.OsuAim = OsuAim;
 exports.OsuAimEvaluator = OsuAimEvaluator;
 exports.OsuDifficultyCalculator = OsuDifficultyCalculator;
+exports.OsuDifficultyHitObject = OsuDifficultyHitObject;
 exports.OsuFlashlight = OsuFlashlight;
 exports.OsuFlashlightEvaluator = OsuFlashlightEvaluator;
 exports.OsuPerformanceCalculator = OsuPerformanceCalculator;
@@ -3559,6 +3803,5 @@ exports.OsuRhythmEvaluator = OsuRhythmEvaluator;
 exports.OsuSpeed = OsuSpeed;
 exports.OsuSpeedEvaluator = OsuSpeedEvaluator;
 exports.PerformanceCalculator = PerformanceCalculator;
-exports.RhythmEvaluator = RhythmEvaluator;
 exports.SpeedEvaluator = SpeedEvaluator;
 //# sourceMappingURL=index.js.map