@rian8337/osu-difficulty-calculator 4.0.0-beta.14 → 4.0.0-beta.16

package/dist/index.js

@@ -29,31 +29,143 @@ class AimEvaluator {
 }
 
 /**
- * Represents a hit object with difficulty calculation values.
+ * The base of a difficulty calculator.
  */
-class DifficultyHitObject {
+class DifficultyCalculator {
     /**
-     * The underlying hitobject.
+     * The calculated beatmap.
      */
-    object;
+    beatmap;
     /**
-     * The index of this hitobject in the list of all hitobjects.
+     * The difficulty objects of the beatmap.
+     */
+    objects = [];
+    /**
+     * The modifications applied.
+     */
+    mods = [];
+    /**
+     * The total star rating of the beatmap.
+     */
+    get total() {
+        return this.attributes.starRating;
+    }
+    /**
+     * The difficulty statistics of the beatmap after modifications are applied.
+     */
+    difficultyStatistics;
+    /**
+     * The strain peaks of various calculated difficulties.
+     */
+    strainPeaks = {
+        aimWithSliders: [],
+        aimWithoutSliders: [],
+        speed: [],
+        flashlight: [],
+    };
+    /**
+     * Constructs a new instance of the calculator.
      *
-     * This is one less than the actual index of the hitobject in the beatmap.
+     * @param beatmap The beatmap to calculate. This beatmap will be deep-cloned to prevent reference changes.
      */
-    index = 0;
+    constructor(beatmap) {
+        this.beatmap = beatmap;
+        this.difficultyStatistics = {
+            circleSize: beatmap.difficulty.cs,
+            approachRate: beatmap.difficulty.ar ?? beatmap.difficulty.od,
+            overallDifficulty: beatmap.difficulty.od,
+            healthDrain: beatmap.difficulty.hp,
+            overallSpeedMultiplier: 1,
+        };
+    }
     /**
-     * The preempt time of the hitobject.
+     * 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.
      */
-    baseTimePreempt = 600;
+    calculate(options) {
+        this.mods = options?.mods ?? [];
+        const converted = new osuBase.BeatmapConverter(this.beatmap).convert({
+            mode: this.mode,
+            mods: this.mods,
+            customSpeedMultiplier: options?.customSpeedMultiplier,
+        });
+        this.difficultyStatistics = Object.seal(this.computeDifficultyStatistics(options));
+        this.populateDifficultyAttributes();
+        this.objects.push(...this.generateDifficultyHitObjects(converted));
+        this.calculateAll();
+        return this;
+    }
     /**
-     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
+     * Calculates the skills provided.
+     *
+     * @param skills The skills to calculate.
      */
-    timePreempt = 600;
+    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 fade in time of the hitobject.
+     * Populates the stored difficulty attributes with necessary data.
      */
-    timeFadeIn = 400;
+    populateDifficultyAttributes() {
+        this.attributes.approachRate = this.difficultyStatistics.approachRate;
+        this.attributes.hitCircleCount = this.beatmap.hitObjects.circles;
+        this.attributes.maxCombo = this.beatmap.maxCombo;
+        this.attributes.mods = this.mods.slice();
+        this.attributes.overallDifficulty =
+            this.difficultyStatistics.overallDifficulty;
+        this.attributes.sliderCount = this.beatmap.hitObjects.sliders;
+        this.attributes.spinnerCount = this.beatmap.hitObjects.spinners;
+        this.attributes.clockRate =
+            this.difficultyStatistics.overallSpeedMultiplier;
+    }
+    /**
+     * Calculates the star rating value of a difficulty.
+     *
+     * @param difficulty The difficulty to calculate.
+     */
+    starValue(difficulty) {
+        return Math.sqrt(difficulty) * this.difficultyMultiplier;
+    }
+    /**
+     * 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;
+    }
+}
+
+/**
+ * Represents a hit object with difficulty calculation values.
+ */
+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;
     /**
      * The aim strain generated by the hitobject if sliders are considered.
      */
@@ -106,30 +218,71 @@ class DifficultyHitObject {
     /**
      * The amount of milliseconds elapsed between this hitobject and the last hitobject.
      */
-    deltaTime = 0;
+    deltaTime;
     /**
      * The amount of milliseconds elapsed since the start time of the previous hitobject, with a minimum of 25ms.
      */
-    strainTime = 0;
+    strainTime;
     /**
      * Adjusted start time of the hitobject, taking speed multiplier into account.
      */
-    startTime = 0;
+    startTime;
     /**
      * Adjusted end time of the hitobject, taking speed multiplier into account.
      */
-    endTime = 0;
+    endTime;
     /**
      * Other hitobjects in the beatmap, including this hitobject.
      */
     hitObjects;
+    normalizedRadius = 50;
+    maximumSliderRadius = this.normalizedRadius * 2.4;
+    assumedSliderRadius = this.normalizedRadius * 1.8;
+    minDeltaTime = 25;
+    lastObject;
+    lastLastObject;
     /**
+     * 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 timePreempt The time preempt with clock rate.
+     * @param isForceAR Whether force AR is enabled.
+     * @param mode The gamemode to compute properties for.
+     */
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate) {
         this.object = object;
-        this.hitObjects = hitObjects;
+        this.lastObject = lastObject;
+        this.lastLastObject = lastLastObject;
+        this.hitObjects = difficultyHitObjects;
+        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, this.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
@@ -171,322 +324,88 @@ class DifficultyHitObject {
             // 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 * 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.
-     *
-     * @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 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));
+    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);
+            }
+            else {
+                this.travelDistance *= Math.pow(1 + this.object.repeatCount / 2.5, 1 / 2.5);
             }
-            return distance <= 2 * this.object.getRadius(osuBase.Modes.droid);
+            this.travelTime = Math.max(this.object.lazyTravelTime / clockRate, this.minDeltaTime);
         }
-        return true;
-    }
-}
-
-/**
- * Represents an osu!droid hit object with difficulty calculation values.
- */
-class DroidDifficultyHitObject extends DifficultyHitObject {
-    /**
-     * The tap strain generated by the hitobject.
-     */
-    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 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;
-    /**
-     * The visual strain generated by the hitobject if sliders are considered.
-     */
-    visualStrainWithSliders = 0;
-    /**
-     * The visual strain generated by the hitobject if sliders are not considered.
-     */
-    visualStrainWithoutSliders = 0;
-    /**
-     * The note density of the hitobject.
-     */
-    noteDensity = 1;
-    /**
-     * The overlapping factor of the hitobject.
-     *
-     * This is used to scale visual skill.
-     */
-    overlappingFactor = 0;
-    /**
-     * @param object The underlying hitobject.
-     * @param hitObjects All difficulty hitobjects in the processed beatmap.
-     */
-    constructor(object, hitObjects) {
-        super(object, hitObjects);
-    }
-}
-
-/**
- * Represents an osu!standard hit object with difficulty calculation values.
- */
-class OsuDifficultyHitObject extends DifficultyHitObject {
-    /**
-     * The speed strain generated by the hitobject.
-     */
-    speedStrain = 0;
-    /**
-     * The flashlight strain generated by this hitobject.
-     */
-    flashlightStrain = 0;
-    /**
-     * @param object The underlying hitobject.
-     * @param hitObjects All difficulty hitobjects in the processed beatmap.
-     */
-    constructor(object, hitObjects) {
-        super(object, hitObjects);
-    }
-}
-
-/**
- * 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;
-    generateDifficultyObjects(params) {
-        params.preempt ??= 600;
-        this.mode = params.mode;
-        if (this.mode === osuBase.Modes.droid) {
-            this.maximumSliderRadius = this.normalizedRadius * 2;
+        // 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;
         }
-        const scalingFactor = this.getScalingFactor(params.objects[0].getRadius(this.mode));
-        const difficultyObjects = [];
-        for (let i = 0; i < params.objects.length; ++i) {
-            const object = this.mode === osuBase.Modes.droid
-                ? new DroidDifficultyHitObject(params.objects[i], difficultyObjects)
-                : new OsuDifficultyHitObject(params.objects[i], difficultyObjects);
-            object.index = difficultyObjects.length - 1;
-            object.timePreempt = params.preempt;
-            object.baseTimePreempt = params.preempt * params.speedMultiplier;
-            if (object.object instanceof osuBase.Slider) {
-                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 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;
-            }
-            if (object instanceof DroidDifficultyHitObject) {
-                // 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;
-                    }
-                    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;
-            }
-            const lastCursorPosition = this.getEndCursorPosition(lastObject.object);
-            object.lazyJumpDistance = object.object
+        // 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, this.minDeltaTime);
+            this.minimumJumpTime = Math.max(this.strainTime - lastTravelTime, 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 = 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.
-            if (osuBase.Precision.almostEqualsNumber(slider.startTime, slider.endTime)) {
-                return;
-            }
-        }
         // Not using slider.endTime due to legacy last tick offset.
         slider.lazyTravelTime =
             slider.nestedHitObjects.at(-1).startTime - slider.startTime;
@@ -502,228 +421,52 @@ 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
                 .getStackedPosition(this.mode)
                 .subtract(currentCursorPosition);
             let currentMovementLength = scalingFactor * currentMovement.length;
-            // The amount of movement required so that the cursor position needs to be updated.
-            let requiredMovement = this.assumedSliderRadius;
-            if (i === slider.nestedHitObjects.length - 1) {
-                // The end of a slider has special aim rules due to the relaxed time constraint on position.
-                // There is both a lazy end position as well as the actual end slider position. We assume the player takes the simpler movement.
-                // For sliders that are circular, the lazy end position may actually be farther away than the sliders' true end.
-                // This code is designed to prevent buffing situations where lazy end is actually a less efficient movement.
-                const lazyMovement = slider.lazyEndPosition.subtract(currentCursorPosition);
-                if (lazyMovement.length < currentMovement.length) {
-                    currentMovement = lazyMovement;
-                }
-                currentMovementLength = scalingFactor * currentMovement.length;
-            }
-            else if (currentMovementObject instanceof osuBase.SliderRepeat) {
-                // For a slider repeat, assume a tighter movement threshold to better assess repeat sliders.
-                requiredMovement = this.normalizedRadius;
-            }
-            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 a difficulty calculator.
- */
-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: [],
-    };
-    /**
-     * 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 ?? 1,
-            oldStatistics: options?.stats?.oldStatistics ?? false,
-        }).calculate({ mode: this.mode });
-        this.preProcess();
-        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),
-        }));
-    }
-    /**
-     * Performs some pre-processing before proceeding with difficulty calculation.
-     */
-    preProcess() {
-    }
-    /**
-     * 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.
-        for (const object of this.objects.slice(1)) {
-            for (const skill of skills) {
-                skill.process(object);
+            // The amount of movement required so that the cursor position needs to be updated.
+            let requiredMovement = this.assumedSliderRadius;
+            if (i === slider.nestedHitObjects.length - 1) {
+                // The end of a slider has special aim rules due to the relaxed time constraint on position.
+                // There is both a lazy end position as well as the actual end slider position. We assume the player takes the simpler movement.
+                // For sliders that are circular, the lazy end position may actually be farther away than the sliders' true end.
+                // This code is designed to prevent buffing situations where lazy end is actually a less efficient movement.
+                const lazyMovement = slider.lazyEndPosition.subtract(currentCursorPosition);
+                if (lazyMovement.length < currentMovement.length) {
+                    currentMovement = lazyMovement;
+                }
+                currentMovementLength = scalingFactor * currentMovement.length;
+            }
+            else if (currentMovementObject instanceof osuBase.SliderRepeat) {
+                // For a slider repeat, assume a tighter movement threshold to better assess repeat sliders.
+                requiredMovement = this.normalizedRadius;
+            }
+            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;
             }
         }
     }
-    /**
-     * 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;
-        this.attributes.clockRate = this.stats.speedMultiplier;
-    }
-    /**
-     * Calculates the star rating value of a difficulty.
-     *
-     * @param difficulty The difficulty to calculate.
-     */
-    starValue(difficulty) {
-        return Math.sqrt(difficulty) * this.difficultyMultiplier;
-    }
-    /**
-     * 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) {
+        let pos = object.getStackedPosition(this.mode);
+        if (object instanceof osuBase.Slider) {
+            this.calculateSliderCursorPosition(object);
+            pos = object.lazyEndPosition ?? pos;
+        }
+        return pos;
     }
 }
 
@@ -1163,7 +906,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;
@@ -1219,8 +962,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;
@@ -1485,7 +1228,7 @@ 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 +=
@@ -1500,7 +1243,7 @@ class DroidVisualEvaluator {
             strain += Math.pow(400 - current.timePreempt, 1.3) / 100;
         }
         if (current.object instanceof osuBase.Slider && withSliders) {
-            const scalingFactor = 50 / current.object.getRadius(osuBase.Modes.droid);
+            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;
@@ -1577,6 +1320,180 @@ class DroidVisual extends DroidSkill {
     }
 }
 
+/**
+ * Represents an osu!droid hit object with difficulty calculation values.
+ */
+class DroidDifficultyHitObject extends DifficultyHitObject {
+    /**
+     * The tap strain generated by the hitobject.
+     */
+    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 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;
+    /**
+     * The visual strain generated by the hitobject if sliders are considered.
+     */
+    visualStrainWithSliders = 0;
+    /**
+     * The visual strain generated by the hitobject if sliders are not considered.
+     */
+    visualStrainWithoutSliders = 0;
+    /**
+     * The note density of the hitobject.
+     */
+    noteDensity = 1;
+    /**
+     * The overlapping factor of the hitobject.
+     *
+     * This is used to scale visual skill.
+     */
+    overlappingFactor = 0;
+    /**
+     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
+     */
+    timePreempt;
+    radiusBuffThreshold = 70;
+    mode = osuBase.Modes.droid;
+    maximumSliderRadius = this.normalizedRadius * 2;
+    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 isForceAR Whether force AR is enabled.
+     */
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, isForceAR) {
+        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate);
+        this.timePreempt = object.timePreempt;
+        if (!isForceAR) {
+            this.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.
+     *
+     * @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 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.radius;
+        }
+        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 / (3 * this.object.radius)) *
+                (7.5 /
+                    (1 +
+                        Math.exp(0.15 * (Math.max(deltaTime, this.minDeltaTime) - 75))));
+    }
+}
+
 /**
  * A difficulty calculator for osu!droid gamemode.
  */
@@ -1584,23 +1501,33 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     /**
      * 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;
+    get visual() {
+        return this.attributes.visualDifficulty;
+    }
     /**
      * The strain threshold to start detecting for possible three-fingered section.
      *
@@ -1608,6 +1535,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      */
     static threeFingerStrainThreshold = 175;
     attributes = {
+        mode: "live",
         tapDifficulty: 0,
         rhythmDifficulty: 0,
         visualDifficulty: 0,
@@ -1662,6 +1590,9 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     }
     difficultyMultiplier = 0.18;
     mode = osuBase.Modes.droid;
+    calculate(options) {
+        return super.calculate(options);
+    }
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -1675,7 +1606,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * Calculates the tap star rating of the beatmap and stores it in this instance.
      */
     calculateTap() {
-        const od = this.stats.od;
+        const od = this.difficultyStatistics.overallDifficulty;
         const tapSkillCheese = new DroidTap(this.mods, od, true);
         const tapSkillNoCheese = new DroidTap(this.mods, od, false);
         this.calculateSkills(tapSkillCheese, tapSkillNoCheese);
@@ -1685,7 +1616,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * Calculates the rhythm star rating of the beatmap and stores it in this instance.
      */
     calculateRhythm() {
-        const rhythmSkill = new DroidRhythm(this.mods, this.stats.od);
+        const rhythmSkill = new DroidRhythm(this.mods, this.difficultyStatistics.overallDifficulty);
         this.calculateSkills(rhythmSkill);
         this.postCalculateRhythm(rhythmSkill);
     }
@@ -1703,7 +1634,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);
@@ -1725,13 +1656,13 @@ 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() {
@@ -1766,15 +1697,31 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             this.visual.toFixed(2) +
             " visual)");
     }
-    preProcess() {
-        const scale = osuBase.CircleSizeCalculator.standardCSToStandardScale(this.stats.cs);
-        for (const object of this.beatmap.hitObjects.objects) {
-            object.droidScale = scale;
+    generateDifficultyHitObjects(beatmap) {
+        const difficultyObjects = [];
+        const { objects } = beatmap.hitObjects;
+        const difficultyAdjustMod = this.mods.find((m) => m instanceof osuBase.ModDifficultyAdjust);
+        for (let i = 0; i < objects.length; ++i) {
+            const difficultyObject = new DroidDifficultyHitObject(objects[i], objects[i - 1] ?? null, objects[i - 2] ?? null, difficultyObjects, this.difficultyStatistics.overallSpeedMultiplier, difficultyAdjustMod?.ar !== undefined);
+            difficultyObject.computeProperties(this.difficultyStatistics.overallSpeedMultiplier, objects);
+            difficultyObjects.push(difficultyObject);
         }
-        osuBase.HitObjectStackEvaluator.applyDroidStacking(this.beatmap.hitObjects.objects, this.beatmap.general.stackLeniency);
+        return difficultyObjects;
+    }
+    computeDifficultyStatistics(options) {
+        const { difficulty } = this.beatmap;
+        return osuBase.calculateDroidDifficultyStatistics({
+            circleSize: difficulty.cs,
+            approachRate: difficulty.ar ?? difficulty.od,
+            overallDifficulty: difficulty.od,
+            healthDrain: difficulty.hp,
+            mods: this.mods,
+            customSpeedMultiplier: options?.customSpeedMultiplier,
+            oldStatistics: options?.oldStatistics,
+        });
     }
     createSkills() {
-        const od = this.stats.od;
+        const od = this.difficultyStatistics.overallDifficulty;
         return [
             new DroidAim(this.mods, true),
             new DroidAim(this.mods, false),
@@ -1797,16 +1744,15 @@ 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.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.calculateAimAttributes();
     }
     /**
@@ -1858,11 +1804,11 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     postCalculateTap(tapSkillCheese) {
         this.strainPeaks.speed = tapSkillCheese.strainPeaks;
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.tap = this.attributes.tapDifficulty = 0;
+            this.attributes.tapDifficulty = 0;
             this.attributes.possibleThreeFingeredSections = [];
         }
         else {
-            this.tap = this.attributes.tapDifficulty = this.starValue(tapSkillCheese.difficultyValue());
+            this.attributes.tapDifficulty = this.starValue(tapSkillCheese.difficultyValue());
         }
         this.calculateTapAttributes();
     }
@@ -1982,7 +1928,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());
     }
@@ -1994,13 +1940,13 @@ 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.ModRelax)) {
-            this.flashlight *= 0.7;
+            this.attributes.flashlightDifficulty *= 0.7;
         }
         const objectStrains = this.objects.map((v) => v.flashlightStrainWithSliders);
         const maxStrain = Math.max(...objectStrains);
@@ -2008,7 +1954,6 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             this.attributes.flashlightDifficultStrainCount =
                 objectStrains.reduce((total, next) => total + Math.pow(next / maxStrain, 4), 0);
         }
-        this.attributes.flashlightDifficulty = this.flashlight;
     }
     /**
      * Called after visual skill calculation.
@@ -2017,7 +1962,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) {
@@ -3069,9 +3014,9 @@ class OsuSpeed extends OsuSkill {
     currentRhythm = 0;
     skillMultiplier = 1375;
     greatWindow;
-    constructor(mods, greatWindow) {
+    constructor(mods, overallDifficulty) {
         super(mods);
-        this.greatWindow = greatWindow;
+        this.greatWindow = new osuBase.OsuHitWindow(overallDifficulty).hitWindowFor300();
     }
     /**
      * @param current The hitobject to calculate.
@@ -3118,7 +3063,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;
@@ -3172,8 +3117,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;
@@ -3210,6 +3155,46 @@ class OsuFlashlight extends OsuSkill {
     }
 }
 
+/**
+ * Represents an osu!standard hit object with difficulty calculation values.
+ */
+class OsuDifficultyHitObject extends DifficultyHitObject {
+    /**
+     * The speed strain generated by the hitobject.
+     */
+    speedStrain = 0;
+    /**
+     * The flashlight strain generated by this hitobject.
+     */
+    flashlightStrain = 0;
+    radiusBuffThreshold = 30;
+    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;
+    }
+    /**
+     * 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.
+     */
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate) {
+        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate);
+    }
+}
+
 /**
  * A difficulty calculator for osu!standard gamemode.
  */
@@ -3217,15 +3202,21 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
     /**
      * 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;
+    get flashlight() {
+        return this.attributes.flashlightDifficulty;
+    }
     attributes = {
         speedDifficulty: 0,
         mods: [],
@@ -3264,10 +3255,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.difficultyStatistics.overallDifficulty);
         this.calculateSkills(speedSkill);
         this.postCalculateSpeed(speedSkill);
     }
@@ -3292,14 +3283,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 =
+            this.attributes.starRating =
                 Math.cbrt(1.14) *
                     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() {
@@ -3312,7 +3303,6 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         const flashlightSkill = skills[3];
         this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
         if (isRelax) {
-            this.speed = 0;
             this.attributes.speedDifficulty = 0;
         }
         else {
@@ -3332,22 +3322,32 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             this.flashlight.toFixed(2) +
             " flashlight)");
     }
-    preProcess() {
-        const scale = osuBase.CircleSizeCalculator.standardCSToStandardScale(this.stats.cs);
-        for (const object of this.beatmap.hitObjects.objects) {
-            object.osuScale = scale;
+    generateDifficultyHitObjects() {
+        const difficultyObjects = [];
+        const { objects } = this.beatmap.hitObjects;
+        for (let i = 0; i < objects.length; ++i) {
+            const difficultyObject = new OsuDifficultyHitObject(objects[i], objects[i - 1] ?? null, objects[i - 2] ?? null, difficultyObjects, this.difficultyStatistics.overallSpeedMultiplier);
+            difficultyObject.computeProperties(this.difficultyStatistics.overallSpeedMultiplier, objects);
+            difficultyObjects.push(difficultyObject);
         }
-        const ar = new osuBase.MapStats({
-            ar: this.beatmap.difficulty.ar,
-            mods: osuBase.ModUtil.removeSpeedChangingMods(this.mods),
-        }).calculate().ar;
-        osuBase.HitObjectStackEvaluator.applyStandardStacking(this.beatmap.formatVersion, this.beatmap.hitObjects.objects, ar, this.beatmap.general.stackLeniency);
+        return difficultyObjects;
+    }
+    computeDifficultyStatistics(options) {
+        const { difficulty } = this.beatmap;
+        return osuBase.calculateOsuDifficultyStatistics({
+            circleSize: difficulty.cs,
+            approachRate: difficulty.ar ?? difficulty.od,
+            overallDifficulty: difficulty.od,
+            healthDrain: difficulty.hp,
+            mods: options?.mods,
+            customSpeedMultiplier: options?.customSpeedMultiplier,
+        });
     }
     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, this.difficultyStatistics.overallDifficulty),
             new OsuFlashlight(this.mods),
         ];
     }
@@ -3360,19 +3360,18 @@ 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;
     }
     /**
      * Called after speed skill calculation.
@@ -3381,7 +3380,7 @@ 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());
     }
     /**
      * Calculates speed-related attributes.
@@ -3400,55 +3399,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()}`;
     }
 }
 
@@ -3675,7 +3632,6 @@ 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;
@@ -3690,7 +3646,6 @@ exports.DroidTapEvaluator = DroidTapEvaluator;
 exports.DroidVisual = DroidVisual;
 exports.DroidVisualEvaluator = DroidVisualEvaluator;
 exports.FlashlightEvaluator = FlashlightEvaluator;
-exports.MapStars = MapStars;
 exports.OsuAim = OsuAim;
 exports.OsuAimEvaluator = OsuAimEvaluator;
 exports.OsuDifficultyCalculator = OsuDifficultyCalculator;