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

package/dist/index.js

@@ -3,137 +3,121 @@
 var osuBase = require('@rian8337/osu-base');
 
 /**
- * The base of a difficulty calculator.
+ * Holds data that can be used to calculate performance points.
  */
-class DifficultyCalculator {
-    /**
-     * The difficulty objects of the beatmap.
-     */
-    get objects() {
-        return this._objects;
-    }
-    /**
-     * The total star rating of the beatmap.
-     */
-    get total() {
-        return this.attributes.starRating;
-    }
-    /**
-     * Constructs a new instance of the calculator.
-     *
-     * @param beatmap The beatmap to calculate.
-     */
-    constructor(beatmap) {
-        /**
-         * The difficulty objects of the beatmap.
-         */
-        this._objects = [];
-        /**
-         * The modifications applied.
-         */
+class DifficultyAttributes {
+    constructor(cacheableAttributes) {
         this.mods = [];
-        /**
-         * The strain peaks of various calculated difficulties.
-         */
-        this.strainPeaks = {
-            aimWithSliders: [],
-            aimWithoutSliders: [],
-            speed: [],
-            flashlight: [],
-        };
-        this.beatmap = beatmap;
+        this.starRating = 0;
+        this.maxCombo = 0;
+        this.aimDifficulty = 0;
+        this.flashlightDifficulty = 0;
+        this.speedNoteCount = 0;
+        this.sliderFactor = 1;
+        this.clockRate = 1;
+        this.overallDifficulty = 0;
+        this.hitCircleCount = 0;
+        this.sliderCount = 0;
+        this.spinnerCount = 0;
+        this.aimDifficultSliderCount = 0;
+        this.aimDifficultStrainCount = 0;
+        if (!cacheableAttributes) {
+            return;
+        }
+        this.mods = osuBase.ModUtil.deserializeMods(cacheableAttributes.mods);
+        this.starRating = cacheableAttributes.starRating;
+        this.maxCombo = cacheableAttributes.maxCombo;
+        this.aimDifficulty = cacheableAttributes.aimDifficulty;
+        this.flashlightDifficulty = cacheableAttributes.flashlightDifficulty;
+        this.speedNoteCount = cacheableAttributes.speedNoteCount;
+        this.sliderFactor = cacheableAttributes.sliderFactor;
+        this.clockRate = cacheableAttributes.clockRate;
+        this.overallDifficulty = cacheableAttributes.overallDifficulty;
+        this.hitCircleCount = cacheableAttributes.hitCircleCount;
+        this.sliderCount = cacheableAttributes.sliderCount;
+        this.spinnerCount = cacheableAttributes.spinnerCount;
+        this.aimDifficultSliderCount =
+            cacheableAttributes.aimDifficultSliderCount;
+        this.aimDifficultStrainCount =
+            cacheableAttributes.aimDifficultStrainCount;
     }
     /**
-     * Calculates the star rating of the specified beatmap.
+     * Converts this `DifficultyAttributes` instance to an attribute structure that can be cached.
      *
-     * 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.
+     * @returns The cacheable attributes.
      */
-    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;
+    toCacheableAttributes() {
+        return Object.assign(Object.assign({}, this), { mods: osuBase.ModUtil.serializeMods(this.mods) });
     }
     /**
-     * Calculates the skills provided.
-     *
-     * @param skills The skills to calculate.
+     * Returns a string representation of the difficulty attributes.
      */
-    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)) {
+    toString() {
+        return `${this.starRating.toFixed(2)} stars`;
+    }
+}
+
+/**
+ * The base of a difficulty calculator.
+ */
+class DifficultyCalculator {
+    constructor() {
+        /**
+         * `Mod`s that adjust the difficulty of a beatmap.
+         */
+        this.difficultyAdjustmentMods = new Set([
+            osuBase.ModDoubleTime,
+            osuBase.ModNightCore,
+            osuBase.ModDifficultyAdjust,
+            osuBase.ModCustomSpeed,
+            osuBase.ModHalfTime,
+            osuBase.ModEasy,
+            osuBase.ModHardRock,
+            osuBase.ModFlashlight,
+            osuBase.ModHidden,
+            osuBase.ModRelax,
+            osuBase.ModAutopilot,
+        ]);
+    }
+    calculate(beatmap, mods = []) {
+        const playableBeatmap = beatmap instanceof osuBase.PlayableBeatmap
+            ? beatmap
+            : this.createPlayableBeatmap(beatmap, mods);
+        const skills = this.createSkills(playableBeatmap);
+        const objects = this.createDifficultyHitObjects(playableBeatmap);
+        for (const object of objects) {
             for (const skill of skills) {
                 skill.process(object);
             }
         }
+        return this.createDifficultyAttributes(playableBeatmap, skills, objects);
     }
-    /**
-     * Obtains the clock rate of the beatmap.
-     *
-     * @param options The options to obtain the clock rate with.
-     * @returns The clock rate of the beatmap.
-     */
-    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));
-    }
-    /**
-     * Populates the stored difficulty attributes with necessary data.
-     *
-     * @param beatmap The beatmap to populate the attributes with.
-     * @param clockRate The clock rate of the beatmap.
-     */
-    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:
-                if (this.mods.some((m) => m instanceof osuBase.ModPrecise)) {
-                    greatWindow = new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od).greatWindow;
-                }
-                else {
-                    greatWindow = new osuBase.DroidHitWindow(beatmap.difficulty.od)
-                        .greatWindow;
-                }
-                break;
-            case osuBase.Modes.osu:
-                greatWindow = new osuBase.OsuHitWindow(beatmap.difficulty.od)
-                    .greatWindow;
-                break;
+    calculateStrainPeaks(beatmap, mods = []) {
+        const playableBeatmap = beatmap instanceof osuBase.PlayableBeatmap
+            ? beatmap
+            : this.createPlayableBeatmap(beatmap, mods);
+        const skills = this.createStrainPeakSkills(playableBeatmap);
+        const objects = this.createDifficultyHitObjects(playableBeatmap);
+        for (const object of objects) {
+            for (const skill of skills) {
+                skill.process(object);
+            }
         }
-        this.attributes.overallDifficulty = osuBase.OsuHitWindow.greatWindowToOD(greatWindow / clockRate);
+        return {
+            aimWithSliders: skills[0].strainPeaks,
+            aimWithoutSliders: skills[1].strainPeaks,
+            speed: skills[2].strainPeaks,
+            flashlight: skills[3].strainPeaks,
+        };
     }
     /**
-     * Calculates the star rating value of a difficulty.
+     * Calculates the base rating of a `Skill`.
      *
-     * @param difficulty The difficulty to calculate.
+     * @param skill The `Skill` to calculate the rating of.
+     * @returns The rating of the `Skill`.
      */
-    starValue(difficulty) {
-        return Math.sqrt(difficulty) * this.difficultyMultiplier;
+    calculateRating(skill) {
+        return Math.sqrt(skill.difficultyValue()) * this.difficultyMultiplier;
     }
     /**
      * Calculates the base performance value of a difficulty rating.
@@ -165,7 +149,7 @@ class DifficultyHitObject {
      * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
      * @param clockRate The clock rate of the beatmap.
      */
-    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate) {
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, index) {
         var _a, _b, _c, _d;
         /**
          * The aim strain generated by the hitobject if sliders are considered.
@@ -230,7 +214,7 @@ class DifficultyHitObject {
             this.fullGreatWindow = ((_d = (_c = object.hitWindow) === null || _c === void 0 ? void 0 : _c.greatWindow) !== null && _d !== void 0 ? _d : 1200) * 2;
         }
         this.fullGreatWindow /= clockRate;
-        this.index = difficultyHitObjects.length - 1;
+        this.index = index;
         // Capped to 25ms to prevent difficulty calculation breaking from simultaneous objects.
         this.startTime = object.startTime / clockRate;
         this.endTime = object.endTime / clockRate;
@@ -267,7 +251,7 @@ class DifficultyHitObject {
      */
     previous(backwardsIndex) {
         var _a;
-        return (_a = this.hitObjects[this.index - backwardsIndex]) !== null && _a !== void 0 ? _a : null;
+        return ((_a = this.hitObjects[this.index - backwardsIndex - 1]) !== null && _a !== void 0 ? _a : null);
     }
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
@@ -281,7 +265,7 @@ class DifficultyHitObject {
      */
     next(forwardsIndex) {
         var _a;
-        return ((_a = this.hitObjects[this.index + forwardsIndex + 2]) !== null && _a !== void 0 ? _a : null);
+        return ((_a = this.hitObjects[this.index + forwardsIndex + 1]) !== null && _a !== void 0 ? _a : null);
     }
     /**
      * Calculates the opacity of the hitobject at a given time.
@@ -532,8 +516,8 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
      * @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);
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, index) {
+        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, index);
         /**
          * The tap strain generated by the hitobject.
          */
@@ -590,6 +574,14 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
         }
         return super.opacityAt(time, mods);
     }
+    previous(backwardsIndex) {
+        var _a;
+        return (_a = this.hitObjects[this.index - backwardsIndex]) !== null && _a !== void 0 ? _a : null;
+    }
+    next(forwardsIndex) {
+        var _a;
+        return ((_a = this.hitObjects[this.index + forwardsIndex + 2]) !== null && _a !== void 0 ? _a : null);
+    }
     /**
      * Determines whether this hitobject is considered overlapping with the hitobject before it.
      *
@@ -994,6 +986,9 @@ class StrainSkill extends Skill {
  */
 class DroidSkill extends StrainSkill {
     process(current) {
+        if (current.index < 0) {
+            return;
+        }
         super.process(current);
         this._objectStrains.push(this.getObjectStrain(current));
     }
@@ -1082,134 +1077,41 @@ class DroidAim extends DroidSkill {
 }
 
 /**
- * An evaluator for calculating osu!droid tap skill.
- */
-class DroidTapEvaluator {
-    /**
-     * Evaluates the difficulty of tapping the current object, based on:
-     *
-     * - time between pressing the previous and current object,
-     * - distance between those objects,
-     * - 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, considerCheesability, strainTimeCap) {
-        if (current.object instanceof osuBase.Spinner ||
-            // Exclude overlapping objects that can be tapped at once.
-            current.isOverlapping(false)) {
-            return 0;
-        }
-        // 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(osuBase.ErrorFunction.erf((this.minSpeedBonus - strainTime) / 40), 2);
-        }
-        return (speedBonus * Math.pow(doubletapness, 1.5) * 1000) / strainTime;
-    }
-}
-// ~200 1/4 BPM streams
-DroidTapEvaluator.minSpeedBonus = 75;
-
-/**
- * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
+ * Holds data that can be used to calculate osu!droid performance points.
  */
-class DroidTap extends DroidSkill {
-    /**
-     * The delta time of hitobjects.
-     */
-    get objectDeltaTimes() {
-        return this._objectDeltaTimes;
-    }
-    constructor(mods, considerCheesability, strainTimeCap) {
-        super(mods);
-        this.reducedSectionCount = 10;
-        this.reducedSectionBaseline = 0.75;
-        this.strainDecayBase = 0.3;
-        this.starsPerDouble = 1.1;
-        this.currentTapStrain = 0;
-        this.currentRhythmMultiplier = 0;
-        this.skillMultiplier = 1.375;
-        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 = osuBase.MathUtils.max(this._objectStrains);
-        if (maxStrain === 0) {
-            return 0;
-        }
-        return this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
-    }
-    /**
-     * The delta time relevant to the difficulty.
-     */
-    relevantDeltaTime() {
-        if (this._objectStrains.length === 0) {
-            return 0;
-        }
-        const maxStrain = osuBase.MathUtils.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) {
-        this.currentTapStrain *= this.strainDecay(current.strainTime);
-        this.currentTapStrain +=
-            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) {
-        if (this.strainTimeCap !== undefined) {
+class DroidDifficultyAttributes extends DifficultyAttributes {
+    constructor(cacheableAttributes) {
+        super(cacheableAttributes);
+        this.tapDifficulty = 0;
+        this.rhythmDifficulty = 0;
+        this.visualDifficulty = 0;
+        this.tapDifficultStrainCount = 0;
+        this.flashlightDifficultStrainCount = 0;
+        this.visualDifficultStrainCount = 0;
+        this.averageSpeedDeltaTime = 0;
+        this.vibroFactor = 1;
+        if (!cacheableAttributes) {
             return;
         }
-        const strain = this.currentTapStrain * this.currentRhythmMultiplier;
-        if (this.considerCheesability) {
-            current.tapStrain = strain;
-        }
-        else {
-            current.originalTapStrain = strain;
-        }
+        this.tapDifficulty = cacheableAttributes.tapDifficulty;
+        this.rhythmDifficulty = cacheableAttributes.rhythmDifficulty;
+        this.visualDifficulty = cacheableAttributes.visualDifficulty;
+        this.tapDifficultStrainCount =
+            cacheableAttributes.tapDifficultStrainCount;
+        this.flashlightDifficultStrainCount =
+            cacheableAttributes.flashlightDifficultStrainCount;
+        this.visualDifficultStrainCount =
+            cacheableAttributes.visualDifficultStrainCount;
+        this.averageSpeedDeltaTime = cacheableAttributes.averageSpeedDeltaTime;
+        this.vibroFactor = cacheableAttributes.vibroFactor;
+    }
+    toString() {
+        return (super.toString() +
+            ` (${this.aimDifficulty.toFixed(2)} aim, ` +
+            `${this.tapDifficulty.toFixed(2)} tap, ` +
+            `${this.rhythmDifficulty.toFixed(2)} rhythm, ` +
+            `${this.flashlightDifficulty.toFixed(2)} flashlight, ` +
+            `${this.visualDifficulty.toFixed(2)} visual)`);
     }
 }
 
@@ -1587,52 +1489,184 @@ class DroidRhythm extends DroidSkill {
 }
 
 /**
- * An evaluator for calculating osu!droid visual skill.
+ * An evaluator for calculating osu!droid tap skill.
  */
-class DroidVisualEvaluator {
+class DroidTapEvaluator {
     /**
-     * Evaluates the difficulty of reading the current object, based on:
+     * Evaluates the difficulty of tapping the current object, based on:
      *
-     * - note density of the current object,
-     * - overlapping factor of the current object,
-     * - the preempt time of the current object,
-     * - the visual opacity of the current object,
-     * - the velocity of the current object if it's a slider,
-     * - past objects' velocity if they are sliders,
-     * - and whether the Hidden mod is enabled.
+     * - time between pressing the previous and current object,
+     * - distance between those objects,
+     * - how easily they can be cheesed,
+     * - and the strain time cap.
      *
      * @param current The current object.
-     * @param mods The mods used.
-     * @param withSliders Whether to take slider difficulty into account.
+     * @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, mods, withSliders) {
+    static evaluateDifficultyOf(current, considerCheesability, strainTimeCap) {
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
-            current.isOverlapping(true) ||
-            current.index === 0) {
+            current.isOverlapping(false)) {
             return 0;
         }
-        // Start with base density and give global bonus for Hidden and Traceable.
-        // Add density caps for sanity.
-        let strain;
-        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
-            strain = Math.min(30, Math.pow(current.noteDensity, 3));
-        }
-        else if (mods.some((m) => m instanceof osuBase.ModTraceable)) {
-            // Give more bonus for hit circles due to there being no circle piece.
-            if (current.object instanceof osuBase.Circle) {
-                strain = Math.min(25, Math.pow(current.noteDensity, 2.5));
-            }
-            else {
-                strain = Math.min(22.5, Math.pow(current.noteDensity, 2.25));
-            }
-        }
-        else {
-            strain = Math.min(20, Math.pow(current.noteDensity, 2));
+        // 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(osuBase.ErrorFunction.erf((this.minSpeedBonus - strainTime) / 40), 2);
         }
-        // Bonus based on how visible the object is.
-        for (let i = 0; i < Math.min(current.index, 10); ++i) {
-            const previous = current.previous(i);
+        return (speedBonus * Math.pow(doubletapness, 1.5) * 1000) / strainTime;
+    }
+}
+// ~200 1/4 BPM streams
+DroidTapEvaluator.minSpeedBonus = 75;
+
+/**
+ * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
+ */
+class DroidTap extends DroidSkill {
+    /**
+     * The delta time of hitobjects.
+     */
+    get objectDeltaTimes() {
+        return this._objectDeltaTimes;
+    }
+    constructor(mods, considerCheesability, strainTimeCap) {
+        super(mods);
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.strainDecayBase = 0.3;
+        this.starsPerDouble = 1.1;
+        this.currentTapStrain = 0;
+        this.currentRhythmMultiplier = 0;
+        this.skillMultiplier = 1.375;
+        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 = osuBase.MathUtils.max(this._objectStrains);
+        if (maxStrain === 0) {
+            return 0;
+        }
+        return this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
+    }
+    /**
+     * The delta time relevant to the difficulty.
+     */
+    relevantDeltaTime() {
+        if (this._objectStrains.length === 0) {
+            return 0;
+        }
+        const maxStrain = osuBase.MathUtils.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) {
+        this.currentTapStrain *= this.strainDecay(current.strainTime);
+        this.currentTapStrain +=
+            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) {
+        if (this.strainTimeCap !== undefined) {
+            return;
+        }
+        const strain = this.currentTapStrain * this.currentRhythmMultiplier;
+        if (this.considerCheesability) {
+            current.tapStrain = strain;
+        }
+        else {
+            current.originalTapStrain = strain;
+        }
+    }
+}
+
+/**
+ * An evaluator for calculating osu!droid visual skill.
+ */
+class DroidVisualEvaluator {
+    /**
+     * Evaluates the difficulty of reading the current object, based on:
+     *
+     * - note density of the current object,
+     * - overlapping factor of the current object,
+     * - the preempt time of the current object,
+     * - the visual opacity of the current object,
+     * - the velocity of the current object if it's a slider,
+     * - past objects' velocity if they are sliders,
+     * - and whether the Hidden mod is enabled.
+     *
+     * @param current The current object.
+     * @param mods The mods used.
+     * @param withSliders Whether to take slider difficulty into account.
+     */
+    static evaluateDifficultyOf(current, mods, withSliders) {
+        if (current.object instanceof osuBase.Spinner ||
+            // Exclude overlapping objects that can be tapped at once.
+            current.isOverlapping(true) ||
+            current.index === 0) {
+            return 0;
+        }
+        // Start with base density and give global bonus for Hidden and Traceable.
+        // Add density caps for sanity.
+        let strain;
+        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
+            strain = Math.min(30, Math.pow(current.noteDensity, 3));
+        }
+        else if (mods.some((m) => m instanceof osuBase.ModTraceable)) {
+            // Give more bonus for hit circles due to there being no circle piece.
+            if (current.object instanceof osuBase.Circle) {
+                strain = Math.min(25, Math.pow(current.noteDensity, 2.5));
+            }
+            else {
+                strain = Math.min(22.5, Math.pow(current.noteDensity, 2.25));
+            }
+        }
+        else {
+            strain = Math.min(20, Math.pow(current.noteDensity, 2));
+        }
+        // Bonus based on how visible the object is.
+        for (let i = 0; i < Math.min(current.index, 10); ++i) {
+            const previous = current.previous(i);
             if (previous.object instanceof osuBase.Spinner ||
                 // Exclude overlapping objects that can be tapped at once.
                 previous.isOverlapping(true)) {
@@ -1733,151 +1767,78 @@ class DroidVisual extends DroidSkill {
     }
 }
 
+/**
+ * Holds data that can be used to calculate osu!droid performance points as well
+ * as doing some analysis using the replay of a score.
+ */
+class ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes {
+    constructor(cacheableAttributes) {
+        super(cacheableAttributes);
+        this.mode = "live";
+        this.possibleThreeFingeredSections = [];
+        this.difficultSliders = [];
+        this.aimNoteCount = 0;
+        this.flashlightSliderFactor = 1;
+        this.visualSliderFactor = 1;
+        if (!cacheableAttributes) {
+            return;
+        }
+        this.possibleThreeFingeredSections =
+            cacheableAttributes.possibleThreeFingeredSections;
+        this.difficultSliders = cacheableAttributes.difficultSliders;
+        this.aimNoteCount = cacheableAttributes.aimNoteCount;
+        this.flashlightSliderFactor =
+            cacheableAttributes.flashlightSliderFactor;
+        this.visualSliderFactor = cacheableAttributes.visualSliderFactor;
+    }
+}
+
 /**
  * A difficulty calculator for osu!droid gamemode.
  */
 class DroidDifficultyCalculator extends DifficultyCalculator {
     constructor() {
-        super(...arguments);
-        this.attributes = {
-            mode: "live",
-            aimDifficultSliderCount: 0,
-            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,
-        };
+        super();
         this.difficultyMultiplier = 0.18;
-        this.mode = osuBase.Modes.droid;
-    }
-    /**
-     * The aim star rating of the beatmap.
-     */
-    get aim() {
-        return this.attributes.aimDifficulty;
-    }
-    /**
-     * The tap star rating of the beatmap.
-     */
-    get tap() {
-        return this.attributes.tapDifficulty;
-    }
-    /**
-     * The rhythm star rating of the beatmap.
-     */
-    get rhythm() {
-        return this.attributes.rhythmDifficulty;
-    }
-    /**
-     * The flashlight star rating of the beatmap.
-     */
-    get flashlight() {
-        return this.attributes.flashlightDifficulty;
-    }
-    /**
-     * The visual star rating of the beatmap.
-     */
-    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.
-     */
-    calculateAim() {
-        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
-            this.attributes.aimDifficulty = 0;
-            return;
-        }
-        const aimSkill = new DroidAim(this.mods, true);
-        const aimSkillWithoutSliders = new DroidAim(this.mods, false);
-        this.calculateSkills(aimSkill, aimSkillWithoutSliders);
-        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
-    }
-    /**
-     * Calculates the tap star rating of the beatmap and stores it in this instance.
-     */
-    calculateTap() {
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.attributes.tapDifficulty = 0;
-            return;
-        }
-        const tapSkillCheese = new DroidTap(this.mods, true);
-        const tapSkillNoCheese = new DroidTap(this.mods, false);
-        this.calculateSkills(tapSkillCheese, tapSkillNoCheese);
-        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() {
-        const rhythmSkill = new DroidRhythm(this.mods);
-        this.calculateSkills(rhythmSkill);
-        this.postCalculateRhythm(rhythmSkill);
-    }
-    /**
-     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
-     */
-    calculateFlashlight() {
-        if (!this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            this.attributes.flashlightDifficulty = 0;
-            return;
-        }
-        const flashlightSkill = new DroidFlashlight(this.mods, true);
-        const flashlightSkillWithoutSliders = new DroidFlashlight(this.mods, false);
-        this.calculateSkills(flashlightSkill, flashlightSkillWithoutSliders);
-        this.postCalculateFlashlight(flashlightSkill, flashlightSkillWithoutSliders);
-    }
-    /**
-     * Calculates the visual star rating of the beatmap and stores it in this instance.
-     */
-    calculateVisual() {
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.attributes.visualDifficulty = 0;
-            return;
-        }
-        const visualSkill = new DroidVisual(this.mods, true);
-        const visualSkillWithoutSliders = new DroidVisual(this.mods, false);
-        this.calculateSkills(visualSkill, visualSkillWithoutSliders);
-        this.postCalculateVisual(visualSkill, visualSkillWithoutSliders);
-    }
-    calculateTotal() {
-        const aimPerformanceValue = this.basePerformanceValue(Math.pow(this.aim, 0.8));
-        const tapPerformanceValue = this.basePerformanceValue(this.tap);
-        const flashlightPerformanceValue = this.mods.some((m) => m instanceof osuBase.ModFlashlight)
-            ? Math.pow(this.flashlight, 1.6) * 25
-            : 0;
-        const visualPerformanceValue = Math.pow(this.visual, 1.6) * 22.5;
+        this.difficultyAdjustmentMods
+            .add(osuBase.ModPrecise)
+            .add(osuBase.ModScoreV2)
+            .add(osuBase.ModTraceable);
+    }
+    retainDifficultyAdjustmentMods(mods) {
+        return mods.filter((mod) => mod.isApplicableToDroid() &&
+            this.difficultyAdjustmentMods.has(mod.constructor) &&
+            mod.isDroidRelevant);
+    }
+    createDifficultyAttributes(beatmap, skills, objects) {
+        const attributes = new ExtendedDroidDifficultyAttributes();
+        attributes.mods = beatmap.mods.slice();
+        attributes.maxCombo = beatmap.maxCombo;
+        attributes.clockRate = beatmap.speedMultiplier;
+        attributes.hitCircleCount = beatmap.hitObjects.circles;
+        attributes.sliderCount = beatmap.hitObjects.sliders;
+        attributes.spinnerCount = beatmap.hitObjects.spinners;
+        this.populateAimAttributes(attributes, skills, objects);
+        this.populateTapAttributes(attributes, skills, objects);
+        this.populateRhythmAttributes(attributes, skills);
+        this.populateFlashlightAttributes(attributes, skills);
+        this.populateVisualAttributes(attributes, skills);
+        if (attributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            attributes.aimDifficulty *= 0.9;
+            attributes.tapDifficulty = 0;
+            attributes.rhythmDifficulty = 0;
+            attributes.flashlightDifficulty *= 0.7;
+            attributes.visualDifficulty = 0;
+        }
+        else if (attributes.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            attributes.aimDifficulty = 0;
+            attributes.flashlightDifficulty *= 0.3;
+            attributes.visualDifficulty *= 0.8;
+        }
+        const aimPerformanceValue = this.basePerformanceValue(Math.pow(attributes.aimDifficulty, 0.8));
+        const tapPerformanceValue = this.basePerformanceValue(attributes.tapDifficulty);
+        const flashlightPerformanceValue = Math.pow(attributes.flashlightDifficulty, 1.6) * 25;
+        const visualPerformanceValue = Math.pow(attributes.visualDifficulty, 1.6) * 22.5;
         const basePerformanceValue = Math.pow(Math.pow(aimPerformanceValue, 1.1) +
             Math.pow(tapPerformanceValue, 1.1) +
             Math.pow(flashlightPerformanceValue, 1.1) +
@@ -1885,126 +1846,82 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         if (basePerformanceValue > 1e-5) {
             // Document for formula derivation:
             // https://docs.google.com/document/d/10DZGYYSsT_yjz2Mtp6yIJld0Rqx4E-vVHupCqiM4TNI/edit
-            this.attributes.starRating =
+            attributes.starRating =
                 0.027 *
                     (Math.cbrt((100000 / Math.pow(2, 1 / 1.1)) * basePerformanceValue) +
                         4);
         }
         else {
-            this.attributes.starRating = 0;
-        }
-    }
-    calculateAll() {
-        const skills = this.createSkills();
-        this.calculateSkills(...skills);
-        const aimSkill = skills.find((s) => s instanceof DroidAim && s.withSliders);
-        const aimSkillWithoutSliders = skills.find((s) => s instanceof DroidAim && !s.withSliders);
-        const rhythmSkill = skills.find((s) => s instanceof DroidRhythm);
-        const tapSkillCheese = skills.find((s) => s instanceof DroidTap && s.considerCheesability);
-        const flashlightSkill = skills.find((s) => s instanceof DroidFlashlight && s.withSliders);
-        const flashlightSkillWithoutSliders = skills.find((s) => s instanceof DroidFlashlight && !s.withSliders);
-        const visualSkill = skills.find((s) => s instanceof DroidVisual && s.withSliders);
-        const visualSkillWithoutSliders = skills.find((s) => s instanceof DroidVisual && !s.withSliders);
-        if (aimSkill && aimSkillWithoutSliders) {
-            this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
-        }
-        if (tapSkillCheese) {
-            const tapSkillVibro = new DroidTap(this.mods, true, tapSkillCheese.relevantDeltaTime());
-            this.calculateSkills(tapSkillVibro);
-            this.postCalculateTap(tapSkillCheese, tapSkillVibro);
+            attributes.starRating = 0;
         }
-        this.postCalculateRhythm(rhythmSkill);
-        if (flashlightSkill && flashlightSkillWithoutSliders) {
-            this.postCalculateFlashlight(flashlightSkill, flashlightSkillWithoutSliders);
+        let greatWindow;
+        if (attributes.mods.some((m) => m instanceof osuBase.ModPrecise)) {
+            greatWindow = new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od)
+                .greatWindow;
         }
-        if (visualSkill && visualSkillWithoutSliders) {
-            this.postCalculateVisual(visualSkill, visualSkillWithoutSliders);
+        else {
+            greatWindow = new osuBase.DroidHitWindow(beatmap.difficulty.od).greatWindow;
         }
-        this.calculateTotal();
+        attributes.overallDifficulty = osuBase.OsuHitWindow.greatWindowToOD(greatWindow / attributes.clockRate);
+        return attributes;
     }
-    toString() {
-        return (this.total.toFixed(2) +
-            " stars (" +
-            this.aim.toFixed(2) +
-            " aim, " +
-            this.tap.toFixed(2) +
-            " tap, " +
-            this.rhythm.toFixed(2) +
-            " rhythm, " +
-            this.flashlight.toFixed(2) +
-            " flashlight, " +
-            this.visual.toFixed(2) +
-            " visual)");
+    createPlayableBeatmap(beatmap, mods) {
+        return beatmap.createDroidPlayableBeatmap(mods);
     }
-    generateDifficultyHitObjects(beatmap, clockRate) {
+    createDifficultyHitObjects(beatmap) {
         var _a, _b;
+        const clockRate = beatmap.speedMultiplier;
         const difficultyObjects = [];
         const { objects } = beatmap.hitObjects;
         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);
+            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, i - 1);
             difficultyObject.computeProperties(clockRate, objects);
             difficultyObjects.push(difficultyObject);
         }
         return difficultyObjects;
     }
-    createSkills() {
+    createSkills(beatmap) {
+        const { mods } = beatmap;
         const skills = [];
-        if (!this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
-            skills.push(new DroidAim(this.mods, true));
-            skills.push(new DroidAim(this.mods, false));
+        if (!mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            skills.push(new DroidAim(mods, true));
+            skills.push(new DroidAim(mods, false));
         }
-        if (!this.mods.some((m) => m instanceof osuBase.ModRelax)) {
+        if (!mods.some((m) => m instanceof osuBase.ModRelax)) {
             // Tap and visual skills depend on rhythm skill, so we put it first
-            skills.push(new DroidRhythm(this.mods));
-            skills.push(new DroidTap(this.mods, true));
-            skills.push(new DroidTap(this.mods, false));
-            skills.push(new DroidVisual(this.mods, true));
-            skills.push(new DroidVisual(this.mods, false));
+            skills.push(new DroidRhythm(mods));
+            skills.push(new DroidTap(mods, true));
+            skills.push(new DroidTap(mods, false));
+            skills.push(new DroidVisual(mods, true));
+            skills.push(new DroidVisual(mods, false));
         }
-        if (this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            skills.push(new DroidFlashlight(this.mods, true));
-            skills.push(new DroidFlashlight(this.mods, false));
+        if (mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            skills.push(new DroidFlashlight(mods, true));
+            skills.push(new DroidFlashlight(mods, false));
         }
         return skills;
     }
-    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.
-     *
-     * @param aimSkill The aim skill that considers sliders.
-     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
-     */
-    postCalculateAim(aimSkill, aimSkillWithoutSliders) {
-        this.strainPeaks.aimWithSliders = aimSkill.strainPeaks;
-        this.strainPeaks.aimWithoutSliders = aimSkillWithoutSliders.strainPeaks;
-        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.attributes.aimDifficulty *= 0.9;
+    createStrainPeakSkills(beatmap) {
+        const { mods } = beatmap;
+        return [
+            new DroidAim(mods, true),
+            new DroidAim(mods, false),
+            new DroidTap(mods, true),
+            new DroidFlashlight(mods, true),
+        ];
+    }
+    populateAimAttributes(attributes, skills, objects) {
+        const aim = skills.find((s) => s instanceof DroidAim && s.withSliders);
+        const aimNoSlider = skills.find((s) => s instanceof DroidAim && !s.withSliders);
+        if (!aim || !aimNoSlider) {
+            return;
         }
-        this.attributes.aimDifficultStrainCount =
-            aimSkill.countDifficultStrains();
-        this.attributes.aimDifficultSliderCount =
-            aimSkill.countDifficultSliders();
-        this.calculateAimAttributes();
-    }
-    /**
-     * Calculates aim-related attributes.
-     */
-    calculateAimAttributes() {
-        this.attributes.difficultSliders = [];
+        attributes.aimDifficulty = this.calculateRating(aim);
+        attributes.aimDifficultSliderCount = aim.countDifficultSliders();
+        attributes.aimDifficultStrainCount = aim.countDifficultStrains();
         const topDifficultSliders = [];
-        for (let i = 0; i < this.objects.length; ++i) {
-            const object = this.objects[i];
+        for (let i = 0; i < objects.length; ++i) {
+            const object = objects[i];
             const velocity = object.travelDistance / object.travelTime;
             if (velocity > 0) {
                 topDifficultSliders.push({
@@ -2018,53 +1935,50 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             const difficultyRating = slider.velocity / velocitySum;
             // Only consider sliders that are fast enough.
             if (difficultyRating > 0.02) {
-                this.attributes.difficultSliders.push({
+                attributes.difficultSliders.push({
                     index: slider.index,
                     difficultyRating: slider.velocity / velocitySum,
                 });
             }
         }
-        this.attributes.difficultSliders.sort((a, b) => b.difficultyRating - a.difficultyRating);
+        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();
+        while (attributes.difficultSliders.length >
+            Math.ceil(0.15 * attributes.sliderCount)) {
+            attributes.difficultSliders.pop();
+        }
+        if (attributes.aimDifficulty > 0) {
+            attributes.sliderFactor =
+                this.calculateRating(aimNoSlider) / attributes.aimDifficulty;
+        }
+        else {
+            attributes.sliderFactor = 1;
         }
     }
-    /**
-     * Called after tap skill calculation.
-     *
-     * @param tapSkillCheese The tap skill that considers cheesing.
-     * @param tapSkillVibro The tap skill that considers vibro.
-     */
-    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 tap-related attributes.
-     */
-    calculateTapAttributes() {
-        this.attributes.possibleThreeFingeredSections = [];
+    populateTapAttributes(attributes, skills, objects) {
+        const tap = skills.find((s) => s instanceof DroidTap && s.considerCheesability);
+        if (!tap) {
+            return;
+        }
+        attributes.tapDifficulty = this.calculateRating(tap);
+        attributes.tapDifficultStrainCount = tap.countDifficultStrains();
+        attributes.speedNoteCount = tap.relevantNoteCount();
+        attributes.averageSpeedDeltaTime = tap.relevantDeltaTime();
+        if (attributes.tapDifficulty > 0) {
+            const tapVibro = new DroidTap(attributes.mods, true, attributes.averageSpeedDeltaTime);
+            for (const object of objects) {
+                tapVibro.process(object);
+            }
+            attributes.vibroFactor =
+                this.calculateRating(tapVibro) / attributes.tapDifficulty;
+        }
         const { threeFingerStrainThreshold } = DroidDifficultyCalculator;
         const minSectionObjectCount = 5;
         let inSpeedSection = false;
         let firstSpeedObjectIndex = 0;
-        for (let i = 2; i < this.objects.length; ++i) {
-            const current = this.objects[i];
-            const prev = this.objects[i - 1];
+        for (let i = 2; i < objects.length; ++i) {
+            const current = objects[i];
+            const prev = objects[i - 1];
             if (!inSpeedSection &&
                 current.originalTapStrain >= threeFingerStrainThreshold) {
                 inSpeedSection = true;
@@ -2080,17 +1994,17 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
                     // 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);
+                    i === objects.length - 1)) {
+                const lastSpeedObjectIndex = i - (i === objects.length - 1 ? 0 : 1);
                 inSpeedSection = false;
                 // Ignore sections that don't meet object count requirement.
                 if (i - firstSpeedObjectIndex < minSectionObjectCount) {
                     continue;
                 }
-                this.attributes.possibleThreeFingeredSections.push({
+                attributes.possibleThreeFingeredSections.push({
                     firstObjectIndex: firstSpeedObjectIndex,
                     lastObjectIndex: lastSpeedObjectIndex,
-                    sumStrain: Math.pow(this.objects
+                    sumStrain: Math.pow(objects
                         .slice(firstSpeedObjectIndex, lastSpeedObjectIndex + 1)
                         .reduce((a, v) => a +
                         v.originalTapStrain /
@@ -2099,61 +2013,47 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             }
         }
     }
-    /**
-     * Called after rhythm skill calculation.
-     *
-     * @param rhythmSkill The rhythm skill.
-     */
-    postCalculateRhythm(rhythmSkill) {
-        this.attributes.rhythmDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
-            ? 0
-            : this.starValue(rhythmSkill.difficultyValue());
-    }
-    /**
-     * Called after flashlight skill calculation.
-     *
-     * @param flashlightSkill The flashlight skill that considers sliders.
-     * @param flashlightSkillWithoutSliders The flashlight skill that doesn't consider sliders.
-     */
-    postCalculateFlashlight(flashlightSkill, flashlightSkillWithoutSliders) {
-        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
-        this.attributes.flashlightDifficulty = this.starValue(flashlightSkill.difficultyValue());
-        if (this.flashlight) {
-            this.attributes.flashlightSliderFactor =
-                this.starValue(flashlightSkillWithoutSliders.difficultyValue()) / this.flashlight;
+    populateRhythmAttributes(attributes, skills) {
+        const rhythm = skills.find((s) => s instanceof DroidRhythm);
+        if (!rhythm) {
+            return;
         }
-        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
-            this.attributes.flashlightDifficulty *= 0.3;
+        attributes.rhythmDifficulty = this.calculateRating(rhythm);
+    }
+    populateFlashlightAttributes(attributes, skills) {
+        const flashlight = skills.find((s) => s instanceof DroidFlashlight && s.withSliders);
+        const flashlightNoSliders = skills.find((s) => s instanceof DroidFlashlight && !s.withSliders);
+        if (!flashlight || !flashlightNoSliders) {
+            return;
         }
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.attributes.flashlightDifficulty *= 0.7;
+        attributes.flashlightDifficulty = this.calculateRating(flashlight);
+        attributes.flashlightDifficultStrainCount =
+            flashlight.countDifficultStrains();
+        if (attributes.flashlightDifficulty > 0) {
+            attributes.flashlightSliderFactor =
+                this.calculateRating(flashlightNoSliders) /
+                    attributes.flashlightDifficulty;
         }
-        else if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
-            this.attributes.flashlightDifficulty *= 0.4;
+        else {
+            attributes.flashlightSliderFactor = 1;
         }
-        this.attributes.flashlightDifficultStrainCount =
-            flashlightSkill.countDifficultStrains();
     }
-    /**
-     * Called after visual skill calculation.
-     *
-     * @param visualSkillWithSliders The visual skill that considers sliders.
-     * @param visualSkillWithoutSliders The visual skill that doesn't consider sliders.
-     */
-    postCalculateVisual(visualSkillWithSliders, visualSkillWithoutSliders) {
-        this.attributes.visualDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
-            ? 0
-            : this.starValue(visualSkillWithSliders.difficultyValue());
-        if (this.visual) {
-            this.attributes.visualSliderFactor =
-                this.starValue(visualSkillWithoutSliders.difficultyValue()) /
-                    this.visual;
+    populateVisualAttributes(attributes, skills) {
+        const visual = skills.find((s) => s instanceof DroidVisual && s.withSliders);
+        const visualNoSliders = skills.find((s) => s instanceof DroidVisual && !s.withSliders);
+        if (!visual || !visualNoSliders) {
+            return;
         }
-        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
-            this.attributes.visualDifficulty *= 0.8;
+        attributes.visualDifficulty = this.calculateRating(visual);
+        attributes.visualDifficultStrainCount = visual.countDifficultStrains();
+        if (attributes.visualDifficulty > 0) {
+            attributes.visualSliderFactor =
+                this.calculateRating(visualNoSliders) /
+                    attributes.visualDifficulty;
+        }
+        else {
+            attributes.visualSliderFactor = 1;
         }
-        this.attributes.visualDifficultStrainCount =
-            visualSkillWithSliders.countDifficultStrains();
     }
 }
 /**
@@ -2189,7 +2089,7 @@ class PerformanceCalculator {
         this.sliderNerfFactor = 1;
         this.difficultyAttributes = difficultyAttributes;
         this.mods = this.isCacheableAttribute(difficultyAttributes)
-            ? osuBase.ModUtil.pcStringToMods(difficultyAttributes.mods)
+            ? osuBase.ModUtil.deserializeMods(difficultyAttributes.mods)
             : difficultyAttributes.mods;
     }
     /**
@@ -3142,62 +3042,149 @@ class OsuAim extends OsuSkill {
 }
 
 /**
- * An evaluator for calculating osu!standard speed skill.
+ * Holds data that can be used to calculate osu!standard performance points.
  */
-class OsuSpeedEvaluator {
+class OsuDifficultyAttributes extends DifficultyAttributes {
+    constructor(cacheableAttributes) {
+        super(cacheableAttributes);
+        this.approachRate = 0;
+        this.speedDifficulty = 0;
+        this.speedDifficultStrainCount = 0;
+        if (!cacheableAttributes) {
+            return;
+        }
+        this.approachRate = cacheableAttributes.approachRate;
+        this.speedDifficulty = cacheableAttributes.speedDifficulty;
+        this.speedDifficultStrainCount =
+            cacheableAttributes.speedDifficultStrainCount;
+    }
+    toString() {
+        return (super.toString() +
+            ` (${this.aimDifficulty.toFixed(2)} aim, ` +
+            `${this.speedDifficulty.toFixed(2)} speed, ` +
+            `${this.flashlightDifficulty.toFixed(2)} flashlight)`);
+    }
+}
+
+/**
+ * An evaluator for calculating osu!standard Flashlight skill.
+ */
+class OsuFlashlightEvaluator {
     /**
-     * Evaluates the difficulty of tapping the current object, based on:
+     * Evaluates the difficulty of memorizing and hitting the current object, based on:
      *
-     * - time between pressing the previous and current object,
-     * - distance between those objects,
-     * - and how easily they can be cheesed.
+     * - distance between a number of previous objects and the current object,
+     * - the visual opacity of the current object,
+     * - the angle made by the current object,
+     * - length and speed of the current object (for sliders),
+     * - and whether Hidden mod is enabled.
      *
      * @param current The current object.
-     * @param mods The mods applied.
+     * @param mods The mods used.
      */
     static evaluateDifficultyOf(current, mods) {
-        var _a;
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
-        const prev = current.previous(0);
-        let strainTime = current.strainTime;
-        // Nerf doubletappable doubles.
-        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 / 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 =
-                0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
+        const scalingFactor = 52 / current.object.radius;
+        let smallDistNerf = 1;
+        let cumulativeStrainTime = 0;
+        let result = 0;
+        let last = current;
+        let angleRepeatCount = 0;
+        for (let i = 0; i < Math.min(current.index, 10); ++i) {
+            const currentObject = current.previous(i);
+            cumulativeStrainTime += last.strainTime;
+            if (!(currentObject.object instanceof osuBase.Spinner)) {
+                const jumpDistance = current.object
+                    .getStackedPosition(osuBase.Modes.osu)
+                    .subtract(currentObject.object.getStackedEndPosition(osuBase.Modes.osu)).length;
+                // We want to nerf objects that can be easily seen within the Flashlight circle radius.
+                if (i === 0) {
+                    smallDistNerf = Math.min(1, jumpDistance / 75);
+                }
+                // We also want to nerf stacks so that only the first object of the stack is accounted for.
+                const stackNerf = Math.min(1, currentObject.lazyJumpDistance / scalingFactor / 25);
+                // Bonus based on how visible the object is.
+                const opacityBonus = 1 +
+                    this.maxOpacityBonus *
+                        (1 -
+                            current.opacityAt(currentObject.object.startTime, mods));
+                result +=
+                    (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
+                        cumulativeStrainTime;
+                if (currentObject.angle !== null && current.angle !== null) {
+                    // Objects further back in time should count less for the nerf.
+                    if (Math.abs(currentObject.angle - current.angle) < 0.02) {
+                        angleRepeatCount += Math.max(0, 1 - 0.1 * i);
+                    }
+                }
+            }
+            last = currentObject;
         }
-        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);
-        // Max distance bonus is 1 * `distance_multiplier` at single_spacing_threshold
-        let distanceBonus = Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 3.95) *
-            this.DISTANCE_MULTIPLIER;
-        if (mods.some((m) => m instanceof osuBase.ModAutopilot)) {
-            distanceBonus = 0;
+        result = Math.pow(smallDistNerf * result, 2);
+        // Additional bonus for Hidden due to there being no approach circles.
+        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
+            result *= 1 + this.hiddenBonus;
         }
-        // Base difficulty with all bonuses
-        const difficulty = ((1 + speedBonus + distanceBonus) * 1000) / strainTime;
-        // Apply penalty if there's doubletappable doubles
-        return difficulty * doubletapness;
+        // Nerf patterns with repeated angles.
+        result *=
+            this.minAngleMultiplier +
+                (1 - this.minAngleMultiplier) / (angleRepeatCount + 1);
+        let sliderBonus = 0;
+        if (current.object instanceof osuBase.Slider) {
+            // Invert the scaling factor to determine the true travel distance independent of circle size.
+            const pixelTravelDistance = current.object.lazyTravelDistance / scalingFactor;
+            // Reward sliders based on velocity.
+            sliderBonus = Math.pow(Math.max(0, pixelTravelDistance / current.travelTime - this.minVelocity), 0.5);
+            // Longer sliders require more memorization.
+            sliderBonus *= pixelTravelDistance;
+            // Nerf sliders with repeats, as less memorization is required.
+            if (current.object.repeatCount > 0)
+                sliderBonus /= current.object.repeatCount + 1;
+        }
+        result += sliderBonus * this.sliderMultiplier;
+        return result;
     }
 }
+OsuFlashlightEvaluator.maxOpacityBonus = 0.4;
+OsuFlashlightEvaluator.hiddenBonus = 0.2;
+OsuFlashlightEvaluator.minVelocity = 0.5;
+OsuFlashlightEvaluator.sliderMultiplier = 1.3;
+OsuFlashlightEvaluator.minAngleMultiplier = 0.2;
+
 /**
- * Spacing threshold for a single hitobject spacing.
- *
- * About 1.25 circles distance between hitobject centers.
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
-OsuSpeedEvaluator.SINGLE_SPACING_THRESHOLD = 125;
-// ~200 1/4 BPM streams
-OsuSpeedEvaluator.minSpeedBonus = 75;
-OsuSpeedEvaluator.DISTANCE_MULTIPLIER = 0.9;
+class OsuFlashlight extends OsuSkill {
+    constructor() {
+        super(...arguments);
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 0;
+        this.reducedSectionBaseline = 1;
+        this.decayWeight = 1;
+        this.currentFlashlightStrain = 0;
+        this.skillMultiplier = 0.05512;
+    }
+    difficultyValue() {
+        return this.strainPeaks.reduce((a, b) => a + b, 0);
+    }
+    strainValueAt(current) {
+        this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
+        this.currentFlashlightStrain +=
+            OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.mods) *
+                this.skillMultiplier;
+        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.flashlightStrain = this.currentFlashlightStrain;
+    }
+}
 
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
@@ -3347,6 +3334,64 @@ OsuRhythmEvaluator.historyObjectsMax = 32;
 OsuRhythmEvaluator.rhythmOverallMultiplier = 0.95;
 OsuRhythmEvaluator.rhythmRatioMultiplier = 12;
 
+/**
+ * An evaluator for calculating osu!standard speed skill.
+ */
+class OsuSpeedEvaluator {
+    /**
+     * Evaluates the difficulty of tapping the current object, based on:
+     *
+     * - time between pressing the previous and current object,
+     * - distance between those objects,
+     * - and how easily they can be cheesed.
+     *
+     * @param current The current object.
+     * @param mods The mods applied.
+     */
+    static evaluateDifficultyOf(current, mods) {
+        var _a;
+        if (current.object instanceof osuBase.Spinner) {
+            return 0;
+        }
+        const prev = current.previous(0);
+        let strainTime = current.strainTime;
+        // Nerf doubletappable doubles.
+        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 / 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 =
+                0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
+        }
+        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);
+        // Max distance bonus is 1 * `distance_multiplier` at single_spacing_threshold
+        let distanceBonus = Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 3.95) *
+            this.DISTANCE_MULTIPLIER;
+        if (mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            distanceBonus = 0;
+        }
+        // Base difficulty with all bonuses
+        const difficulty = ((1 + speedBonus + distanceBonus) * 1000) / strainTime;
+        // Apply penalty if there's doubletappable doubles
+        return difficulty * doubletapness;
+    }
+}
+/**
+ * Spacing threshold for a single hitobject spacing.
+ *
+ * About 1.25 circles distance between hitobject centers.
+ */
+OsuSpeedEvaluator.SINGLE_SPACING_THRESHOLD = 125;
+// ~200 1/4 BPM streams
+OsuSpeedEvaluator.minSpeedBonus = 75;
+OsuSpeedEvaluator.DISTANCE_MULTIPLIER = 0.9;
+
 /**
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
@@ -3361,6 +3406,19 @@ class OsuSpeed extends OsuSkill {
         this.currentRhythm = 0;
         this.skillMultiplier = 1.46;
     }
+    /**
+     * The amount of notes that are relevant to the difficulty.
+     */
+    relevantNoteCount() {
+        if (this._objectStrains.length === 0) {
+            return 0;
+        }
+        const maxStrain = osuBase.MathUtils.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.
      */
@@ -3389,360 +3447,136 @@ class OsuSpeed extends OsuSkill {
     }
 }
 
-/**
- * An evaluator for calculating osu!standard Flashlight skill.
- */
-class OsuFlashlightEvaluator {
-    /**
-     * Evaluates the difficulty of memorizing and hitting the current object, based on:
-     *
-     * - distance between a number of previous objects and the current object,
-     * - the visual opacity of the current object,
-     * - the angle made by the current object,
-     * - length and speed of the current object (for sliders),
-     * - and whether Hidden mod is enabled.
-     *
-     * @param current The current object.
-     * @param mods The mods used.
-     */
-    static evaluateDifficultyOf(current, mods) {
-        if (current.object instanceof osuBase.Spinner) {
-            return 0;
-        }
-        const scalingFactor = 52 / current.object.radius;
-        let smallDistNerf = 1;
-        let cumulativeStrainTime = 0;
-        let result = 0;
-        let last = current;
-        let angleRepeatCount = 0;
-        for (let i = 0; i < Math.min(current.index, 10); ++i) {
-            const currentObject = current.previous(i);
-            cumulativeStrainTime += last.strainTime;
-            if (!(currentObject.object instanceof osuBase.Spinner)) {
-                const jumpDistance = current.object
-                    .getStackedPosition(osuBase.Modes.osu)
-                    .subtract(currentObject.object.getStackedEndPosition(osuBase.Modes.osu)).length;
-                // We want to nerf objects that can be easily seen within the Flashlight circle radius.
-                if (i === 0) {
-                    smallDistNerf = Math.min(1, jumpDistance / 75);
-                }
-                // We also want to nerf stacks so that only the first object of the stack is accounted for.
-                const stackNerf = Math.min(1, currentObject.lazyJumpDistance / scalingFactor / 25);
-                // Bonus based on how visible the object is.
-                const opacityBonus = 1 +
-                    this.maxOpacityBonus *
-                        (1 -
-                            current.opacityAt(currentObject.object.startTime, mods));
-                result +=
-                    (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
-                        cumulativeStrainTime;
-                if (currentObject.angle !== null && current.angle !== null) {
-                    // Objects further back in time should count less for the nerf.
-                    if (Math.abs(currentObject.angle - current.angle) < 0.02) {
-                        angleRepeatCount += Math.max(0, 1 - 0.1 * i);
-                    }
-                }
-            }
-            last = currentObject;
-        }
-        result = Math.pow(smallDistNerf * result, 2);
-        // Additional bonus for Hidden due to there being no approach circles.
-        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
-            result *= 1 + this.hiddenBonus;
-        }
-        // Nerf patterns with repeated angles.
-        result *=
-            this.minAngleMultiplier +
-                (1 - this.minAngleMultiplier) / (angleRepeatCount + 1);
-        let sliderBonus = 0;
-        if (current.object instanceof osuBase.Slider) {
-            // Invert the scaling factor to determine the true travel distance independent of circle size.
-            const pixelTravelDistance = current.object.lazyTravelDistance / scalingFactor;
-            // Reward sliders based on velocity.
-            sliderBonus = Math.pow(Math.max(0, pixelTravelDistance / current.travelTime - this.minVelocity), 0.5);
-            // Longer sliders require more memorization.
-            sliderBonus *= pixelTravelDistance;
-            // Nerf sliders with repeats, as less memorization is required.
-            if (current.object.repeatCount > 0)
-                sliderBonus /= current.object.repeatCount + 1;
-        }
-        result += sliderBonus * this.sliderMultiplier;
-        return result;
-    }
-}
-OsuFlashlightEvaluator.maxOpacityBonus = 0.4;
-OsuFlashlightEvaluator.hiddenBonus = 0.2;
-OsuFlashlightEvaluator.minVelocity = 0.5;
-OsuFlashlightEvaluator.sliderMultiplier = 1.3;
-OsuFlashlightEvaluator.minAngleMultiplier = 0.2;
-
-/**
- * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
- */
-class OsuFlashlight extends OsuSkill {
-    constructor() {
-        super(...arguments);
-        this.strainDecayBase = 0.15;
-        this.reducedSectionCount = 0;
-        this.reducedSectionBaseline = 1;
-        this.decayWeight = 1;
-        this.currentFlashlightStrain = 0;
-        this.skillMultiplier = 0.05512;
-    }
-    difficultyValue() {
-        return this.strainPeaks.reduce((a, b) => a + b, 0);
-    }
-    strainValueAt(current) {
-        this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
-        this.currentFlashlightStrain +=
-            OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.mods) *
-                this.skillMultiplier;
-        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.flashlightStrain = this.currentFlashlightStrain;
-    }
-}
-
 /**
  * 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,
-            aimDifficultSliderCount: 0,
-            aimDifficultStrainCount: 0,
-            speedDifficultStrainCount: 0,
-        };
+        super();
         this.difficultyMultiplier = 0.0675;
-        this.mode = osuBase.Modes.osu;
-    }
-    /**
-     * The aim star rating of the beatmap.
-     */
-    get aim() {
-        return this.attributes.aimDifficulty;
-    }
-    /**
-     * The speed star rating of the beatmap.
-     */
-    get speed() {
-        return this.attributes.speedDifficulty;
-    }
-    /**
-     * The flashlight star rating of the beatmap.
-     */
-    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.
-     */
-    calculateAim() {
-        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
-            this.attributes.aimDifficulty = 0;
-            return;
-        }
-        const aimSkill = new OsuAim(this.mods, true);
-        const aimSkillWithoutSliders = new OsuAim(this.mods, false);
-        this.calculateSkills(aimSkill, aimSkillWithoutSliders);
-        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
-    }
-    /**
-     * Calculates the speed star rating of the beatmap and stores it in this instance.
-     */
-    calculateSpeed() {
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.attributes.speedDifficulty = 0;
-            return;
-        }
-        const speedSkill = new OsuSpeed(this.mods);
-        this.calculateSkills(speedSkill);
-        this.postCalculateSpeed(speedSkill);
-    }
-    /**
-     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
-     */
-    calculateFlashlight() {
-        if (!this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            this.attributes.flashlightDifficulty = 0;
-            return;
-        }
-        const flashlightSkill = new OsuFlashlight(this.mods);
-        this.calculateSkills(flashlightSkill);
-        this.postCalculateFlashlight(flashlightSkill);
-    }
-    calculateTotal() {
-        const aimPerformanceValue = this.basePerformanceValue(this.aim);
-        const speedPerformanceValue = this.basePerformanceValue(this.speed);
-        let flashlightPerformanceValue = 0;
-        if (this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            flashlightPerformanceValue = Math.pow(this.flashlight, 2) * 25;
-        }
+        this.difficultyAdjustmentMods.add(osuBase.ModTouchDevice);
+    }
+    retainDifficultyAdjustmentMods(mods) {
+        return mods.filter((mod) => mod.isApplicableToOsu() &&
+            this.difficultyAdjustmentMods.has(mod.constructor) &&
+            mod.isOsuRelevant);
+    }
+    createDifficultyAttributes(beatmap, skills) {
+        const attributes = new OsuDifficultyAttributes();
+        attributes.mods = beatmap.mods.slice();
+        attributes.maxCombo = beatmap.maxCombo;
+        attributes.clockRate = beatmap.speedMultiplier;
+        attributes.hitCircleCount = beatmap.hitObjects.circles;
+        attributes.sliderCount = beatmap.hitObjects.sliders;
+        attributes.spinnerCount = beatmap.hitObjects.spinners;
+        this.populateAimAttributes(attributes, skills);
+        this.populateSpeedAttributes(attributes, skills);
+        this.populateFlashlightAttributes(attributes, skills);
+        if (attributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            attributes.aimDifficulty *= 0.9;
+            attributes.speedDifficulty = 0;
+            attributes.flashlightDifficulty *= 0.7;
+        }
+        else if (attributes.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            attributes.aimDifficulty = 0;
+            attributes.speedDifficulty *= 0.5;
+            attributes.flashlightDifficulty *= 0.4;
+        }
+        const aimPerformanceValue = this.basePerformanceValue(attributes.aimDifficulty);
+        const speedPerformanceValue = this.basePerformanceValue(attributes.speedDifficulty);
+        const flashlightPerformanceValue = Math.pow(attributes.flashlightDifficulty, 2) * 25;
         const basePerformanceValue = Math.pow(Math.pow(aimPerformanceValue, 1.1) +
             Math.pow(speedPerformanceValue, 1.1) +
             Math.pow(flashlightPerformanceValue, 1.1), 1 / 1.1);
         if (basePerformanceValue > 1e-5) {
             // Document for formula derivation:
             // https://docs.google.com/document/d/10DZGYYSsT_yjz2Mtp6yIJld0Rqx4E-vVHupCqiM4TNI/edit
-            this.attributes.starRating =
+            attributes.starRating =
                 Math.cbrt(1.15) *
                     0.027 *
                     (Math.cbrt((100000 / Math.pow(2, 1 / 1.1)) * basePerformanceValue) +
                         4);
         }
         else {
-            this.attributes.starRating = 0;
+            attributes.starRating = 0;
         }
+        const preempt = osuBase.BeatmapDifficulty.difficultyRange(beatmap.difficulty.ar, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin) / attributes.clockRate;
+        attributes.approachRate = osuBase.BeatmapDifficulty.inverseDifficultyRange(preempt, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin);
+        const { greatWindow } = new osuBase.OsuHitWindow(beatmap.difficulty.od);
+        attributes.overallDifficulty = osuBase.OsuHitWindow.greatWindowToOD(greatWindow / attributes.clockRate);
+        return attributes;
     }
-    calculateAll() {
-        const skills = this.createSkills();
-        this.calculateSkills(...skills);
-        const aimSkill = skills.find((s) => s instanceof OsuAim && s.withSliders);
-        const aimSkillWithoutSliders = skills.find((s) => s instanceof OsuAim && !s.withSliders);
-        const speedSkill = skills.find((s) => s instanceof OsuSpeed);
-        const flashlightSkill = skills.find((s) => s instanceof OsuFlashlight);
-        if (aimSkill && aimSkillWithoutSliders) {
-            this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
-        }
-        if (speedSkill) {
-            this.postCalculateSpeed(speedSkill);
-        }
-        if (flashlightSkill) {
-            this.postCalculateFlashlight(flashlightSkill);
-        }
-        this.calculateTotal();
-    }
-    toString() {
-        return (this.total.toFixed(2) +
-            " stars (" +
-            this.aim.toFixed(2) +
-            " aim, " +
-            this.speed.toFixed(2) +
-            " speed, " +
-            this.flashlight.toFixed(2) +
-            " flashlight)");
+    createPlayableBeatmap(beatmap, mods) {
+        return beatmap.createOsuPlayableBeatmap(mods);
     }
-    generateDifficultyHitObjects(beatmap, clockRate) {
-        var _a, _b;
+    createDifficultyHitObjects(beatmap) {
+        var _a;
+        const clockRate = beatmap.speedMultiplier;
         const difficultyObjects = [];
         const { objects } = beatmap.hitObjects;
-        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);
+        for (let i = 1; i < objects.length; ++i) {
+            const difficultyObject = new OsuDifficultyHitObject(objects[i], objects[i - 1], (_a = objects[i - 2]) !== null && _a !== void 0 ? _a : null, difficultyObjects, clockRate, i - 1);
             difficultyObject.computeProperties(clockRate, objects);
             difficultyObjects.push(difficultyObject);
         }
         return difficultyObjects;
     }
-    createSkills() {
+    createSkills(beatmap) {
+        const { mods } = beatmap;
         const skills = [];
-        if (!this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
-            skills.push(new OsuAim(this.mods, true));
-            skills.push(new OsuAim(this.mods, false));
+        if (!mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            skills.push(new OsuAim(mods, true));
+            skills.push(new OsuAim(mods, false));
         }
-        if (!this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            skills.push(new OsuSpeed(this.mods));
+        if (!mods.some((m) => m instanceof osuBase.ModRelax)) {
+            skills.push(new OsuSpeed(mods));
         }
-        if (this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            skills.push(new OsuFlashlight(this.mods));
+        if (mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            skills.push(new OsuFlashlight(mods));
         }
         return skills;
     }
-    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.
-     *
-     * @param aimSkill The aim skill that considers sliders.
-     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
-     */
-    postCalculateAim(aimSkill, aimSkillWithoutSliders) {
-        this.strainPeaks.aimWithSliders = aimSkill.strainPeaks;
-        this.strainPeaks.aimWithoutSliders = aimSkillWithoutSliders.strainPeaks;
-        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.attributes.aimDifficulty = Math.pow(this.aim, 0.8);
+    createStrainPeakSkills(beatmap) {
+        const { mods } = beatmap;
+        return [
+            new OsuAim(mods, true),
+            new OsuAim(mods, false),
+            new OsuSpeed(mods),
+            new OsuFlashlight(mods),
+        ];
+    }
+    populateAimAttributes(attributes, skills) {
+        const aim = skills.find((s) => s instanceof OsuAim && s.withSliders);
+        const aimNoSlider = skills.find((s) => s instanceof OsuAim && !s.withSliders);
+        if (!aim || !aimNoSlider) {
+            return;
         }
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.attributes.aimDifficulty *= 0.9;
+        attributes.aimDifficulty = this.calculateRating(aim);
+        attributes.aimDifficultSliderCount = aim.countDifficultSliders();
+        attributes.aimDifficultStrainCount = aim.countDifficultStrains();
+        if (attributes.aimDifficulty > 0) {
+            attributes.sliderFactor =
+                this.calculateRating(aimNoSlider) / attributes.aimDifficulty;
         }
-        else if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
-            this.attributes.aimDifficulty = 0;
+        else {
+            attributes.sliderFactor = 1;
         }
-        this.attributes.aimDifficultStrainCount =
-            aimSkill.countDifficultStrains();
-        this.attributes.aimDifficultSliderCount =
-            aimSkill.countDifficultSliders();
     }
-    /**
-     * Called after speed skill calculation.
-     *
-     * @param speedSkill The speed skill.
-     */
-    postCalculateSpeed(speedSkill) {
-        this.strainPeaks.speed = speedSkill.strainPeaks;
-        this.attributes.speedDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
-            ? 0
-            : this.starValue(speedSkill.difficultyValue());
-        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
-            this.attributes.speedDifficulty *= 0.5;
-        }
-        this.attributes.speedDifficultStrainCount =
-            speedSkill.countDifficultStrains();
-        const objectStrains = this.objects.map((v) => v.speedStrain);
-        const maxStrain = osuBase.MathUtils.max(objectStrains);
-        if (maxStrain) {
-            this.attributes.speedNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
+    populateSpeedAttributes(attributes, skills) {
+        const speed = skills.find((s) => s instanceof OsuSpeed);
+        if (!speed) {
+            return;
         }
+        attributes.speedDifficulty = this.calculateRating(speed);
+        attributes.speedNoteCount = speed.relevantNoteCount();
+        attributes.speedDifficultStrainCount = speed.countDifficultStrains();
     }
-    /**
-     * Called after flashlight skill calculation.
-     *
-     * @param flashlightSkill The flashlight skill.
-     */
-    postCalculateFlashlight(flashlightSkill) {
-        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
-        this.attributes.flashlightDifficulty = this.starValue(flashlightSkill.difficultyValue());
-        if (this.mods.some((m) => m instanceof osuBase.ModTouchDevice)) {
-            this.attributes.flashlightDifficulty = Math.pow(this.flashlight, 0.8);
-        }
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.attributes.flashlightDifficulty *= 0.7;
-        }
-        else if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
-            this.attributes.flashlightDifficulty *= 0.4;
+    populateFlashlightAttributes(attributes, skills) {
+        const flashlight = skills.find((s) => s instanceof OsuFlashlight);
+        if (!flashlight) {
+            return;
         }
+        attributes.flashlightDifficulty = this.calculateRating(flashlight);
     }
 }
 
@@ -4076,10 +3910,12 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
     }
 }
 
+exports.DifficultyAttributes = DifficultyAttributes;
 exports.DifficultyCalculator = DifficultyCalculator;
 exports.DifficultyHitObject = DifficultyHitObject;
 exports.DroidAim = DroidAim;
 exports.DroidAimEvaluator = DroidAimEvaluator;
+exports.DroidDifficultyAttributes = DroidDifficultyAttributes;
 exports.DroidDifficultyCalculator = DroidDifficultyCalculator;
 exports.DroidDifficultyHitObject = DroidDifficultyHitObject;
 exports.DroidFlashlight = DroidFlashlight;
@@ -4091,8 +3927,10 @@ exports.DroidTap = DroidTap;
 exports.DroidTapEvaluator = DroidTapEvaluator;
 exports.DroidVisual = DroidVisual;
 exports.DroidVisualEvaluator = DroidVisualEvaluator;
+exports.ExtendedDroidDifficultyAttributes = ExtendedDroidDifficultyAttributes;
 exports.OsuAim = OsuAim;
 exports.OsuAimEvaluator = OsuAimEvaluator;
+exports.OsuDifficultyAttributes = OsuDifficultyAttributes;
 exports.OsuDifficultyCalculator = OsuDifficultyCalculator;
 exports.OsuDifficultyHitObject = OsuDifficultyHitObject;
 exports.OsuFlashlight = OsuFlashlight;