@rian8337/osu-difficulty-calculator 3.0.0-beta.19 → 3.0.0-beta.20

package/dist/index.js

@@ -573,13 +573,6 @@ class DifficultyCalculator {
         speed: [],
         flashlight: [],
     };
-    /**
-     * Additional data that is used in performance calculation.
-     */
-    attributes = {
-        speedNoteCount: 0,
-        sliderFactor: 1,
-    };
     sectionLength = 400;
     /**
      * Constructs a new instance of the calculator.
@@ -615,6 +608,7 @@ class DifficultyCalculator {
             speedMultiplier: options?.stats?.speedMultiplier,
             oldStatistics: options?.stats?.oldStatistics,
         }).calculate({ mode: this.mode });
+        this.populateDifficultyAttributes();
         this.generateDifficultyHitObjects();
         this.calculateAll();
         return this;
@@ -650,6 +644,18 @@ class DifficultyCalculator {
             });
         });
     }
+    /**
+     * Populates the stored difficulty attributes with necessary data.
+     */
+    populateDifficultyAttributes() {
+        this.attributes.approachRate = this.stats.ar;
+        this.attributes.hitCircleCount = this.beatmap.hitObjects.circles;
+        this.attributes.maxCombo = this.beatmap.maxCombo;
+        this.attributes.mods = this.mods.slice();
+        this.attributes.overallDifficulty = this.stats.od;
+        this.attributes.sliderCount = this.beatmap.hitObjects.sliders;
+        this.attributes.spinnerCount = this.beatmap.hitObjects.spinners;
+    }
     /**
      * Calculates the star rating value of a difficulty.
      *
@@ -1484,6 +1490,23 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     visual = 0;
     difficultyMultiplier = 0.18;
     mode = osuBase.Modes.droid;
+    attributes = {
+        tapDifficulty: 0,
+        rhythmDifficulty: 0,
+        visualDifficulty: 0,
+        mods: [],
+        starRating: 0,
+        maxCombo: 0,
+        aimDifficulty: 0,
+        flashlightDifficulty: 0,
+        speedNoteCount: 0,
+        sliderFactor: 0,
+        approachRate: 0,
+        overallDifficulty: 0,
+        hitCircleCount: 0,
+        sliderCount: 0,
+        spinnerCount: 0,
+    };
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -1640,6 +1663,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.aim *= 0.9;
         }
+        this.attributes.aimDifficulty = this.aim;
     }
     /**
      * Called after tap skill calculation.
@@ -1648,7 +1672,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      */
     postCalculateTap(tapSkill) {
         this.strainPeaks.speed = tapSkill.strainPeaks;
-        this.tap = this.starValue(tapSkill.difficultyValue());
+        this.tap = this.attributes.tapDifficulty = this.starValue(tapSkill.difficultyValue());
     }
     /**
      * Calculates speed-related attributes.
@@ -1666,7 +1690,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * @param rhythmSkill The rhythm skill.
      */
     postCalculateRhythm(rhythmSkill) {
-        this.rhythm = this.mods.some((m) => m instanceof osuBase.ModRelax)
+        this.rhythm = this.attributes.rhythmDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
             ? 0
             : this.starValue(rhythmSkill.difficultyValue());
     }
@@ -1681,6 +1705,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.flashlight *= 0.7;
         }
+        this.attributes.flashlightDifficulty = this.flashlight;
     }
     /**
      * Called after visual skill calculation.
@@ -1688,7 +1713,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * @param visualSkill The visual skill.
      */
     postCalculateVisual(visualSkill) {
-        this.visual = this.mods.some((m) => m instanceof osuBase.ModRelax)
+        this.visual = this.attributes.visualDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
             ? 0
             : this.starValue(visualSkill.difficultyValue());
     }
@@ -1706,10 +1731,6 @@ class PerformanceCalculator {
      * The calculated accuracy.
      */
     computedAccuracy = new osuBase.Accuracy({});
-    /**
-     * The difficulty calculator that is being calculated.
-     */
-    difficultyCalculator;
     /**
      * Penalty for combo breaks.
      */
@@ -1722,12 +1743,6 @@ class PerformanceCalculator {
      * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
      */
     sliderNerfFactor = 1;
-    /**
-     * @param difficultyCalculator The difficulty calculator to calculate.
-     */
-    constructor(difficultyCalculator) {
-        this.difficultyCalculator = difficultyCalculator;
-    }
     /**
      * Calculates the performance points of the beatmap.
      *
@@ -1740,6 +1755,14 @@ class PerformanceCalculator {
         this.calculateTotalValue();
         return this;
     }
+    /**
+     * The total hits that can be done in the beatmap.
+     */
+    get totalHits() {
+        return (this.difficultyAttributes.hitCircleCount +
+            this.difficultyAttributes.sliderCount +
+            this.difficultyAttributes.spinnerCount);
+    }
     /**
      * Calculates the base performance value of a star rating.
      */
@@ -1752,7 +1775,7 @@ class PerformanceCalculator {
      * @param options Options for performance calculation.
      */
     handleOptions(options) {
-        const maxCombo = this.difficultyCalculator.beatmap.maxCombo;
+        const maxCombo = this.difficultyAttributes.maxCombo;
         const miss = this.computedAccuracy.nmiss;
         const combo = options?.combo ?? maxCombo - miss;
         this.comboPenalty = Math.min(Math.pow(combo / maxCombo, 0.8), 1);
@@ -1761,7 +1784,7 @@ class PerformanceCalculator {
             this.computedAccuracy = new osuBase.Accuracy(options.accPercent);
             if (this.computedAccuracy.n300 <= 0) {
                 this.computedAccuracy.n300 =
-                    this.difficultyCalculator.objects.length -
+                    this.totalHits -
                         this.computedAccuracy.n100 -
                         this.computedAccuracy.n50 -
                         this.computedAccuracy.nmiss;
@@ -1770,49 +1793,50 @@ class PerformanceCalculator {
         else {
             this.computedAccuracy = new osuBase.Accuracy({
                 percent: options?.accPercent,
-                nobjects: this.difficultyCalculator.objects.length,
+                nobjects: this.totalHits,
                 nmiss: options?.miss || 0,
             });
         }
         this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo);
-        if (this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModNoFail)) {
+        if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModNoFail)) {
             this.finalMultiplier *= Math.max(0.9, 1 - 0.02 * this.effectiveMissCount);
         }
-        if (this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModSpunOut)) {
+        if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModSpunOut)) {
             this.finalMultiplier *=
                 1 -
-                    Math.pow(this.difficultyCalculator.beatmap.hitObjects.spinners /
-                        this.difficultyCalculator.objects.length, 0.85);
+                    Math.pow(this.difficultyAttributes.spinnerCount / this.totalHits, 0.85);
         }
-        if (this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModRelax)) {
+        if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
             // Graph: https://www.desmos.com/calculator/bc9eybdthb
             // We use OD13.3 as maximum since it's the value at which great hit window becomes 0.
-            const n100Multiplier = Math.max(0, this.difficultyCalculator.stats.od > 0
+            const n100Multiplier = Math.max(0, this.difficultyAttributes.overallDifficulty > 0
                 ? 1 -
-                    Math.pow(this.difficultyCalculator.stats.od / 13.33, 1.8)
+                    Math.pow(this.difficultyAttributes.overallDifficulty /
+                        13.33, 1.8)
                 : 1);
-            const n50Multiplier = Math.max(0, this.difficultyCalculator.stats.od > 0.0
+            const n50Multiplier = Math.max(0, this.difficultyAttributes.overallDifficulty > 0.0
                 ? 1 -
-                    Math.pow(this.difficultyCalculator.stats.od / 13.33, 5)
+                    Math.pow(this.difficultyAttributes.overallDifficulty /
+                        13.33, 5)
                 : 1);
             // As we're adding 100s and 50s to an approximated number of combo breaks, the result can be higher
             // than total hits in specific scenarios (which breaks some calculations),  so we need to clamp it.
             this.effectiveMissCount = Math.min(this.effectiveMissCount +
                 this.computedAccuracy.n100 * n100Multiplier +
-                this.computedAccuracy.n50 * n50Multiplier, this.difficultyCalculator.objects.length);
+                this.computedAccuracy.n50 * n50Multiplier, this.totalHits);
         }
-        if (this.difficultyCalculator.beatmap.hitObjects.sliders > 0) {
+        if (this.difficultyAttributes.sliderCount > 0) {
             // We assume 15% of sliders in a beatmap are difficult since there's no way to tell from the performance calculator.
-            const estimateDifficultSliders = this.difficultyCalculator.beatmap.hitObjects.sliders * 0.15;
+            const estimateDifficultSliders = this.difficultyAttributes.sliderCount * 0.15;
             const estimateSliderEndsDropped = osuBase.MathUtils.clamp(Math.min(this.computedAccuracy.n300 +
                 this.computedAccuracy.n50 +
                 this.computedAccuracy.nmiss, maxCombo - combo), 0, estimateDifficultSliders);
             this.sliderNerfFactor =
-                (1 - this.difficultyCalculator.attributes.sliderFactor) *
+                (1 - this.difficultyAttributes.sliderFactor) *
                     Math.pow(1 -
                         estimateSliderEndsDropped /
                             estimateDifficultSliders, 3) +
-                    this.difficultyCalculator.attributes.sliderFactor;
+                    this.difficultyAttributes.sliderFactor;
         }
     }
     /**
@@ -1820,14 +1844,13 @@ class PerformanceCalculator {
      */
     calculateEffectiveMissCount(combo, maxCombo) {
         let comboBasedMissCount = 0;
-        if (this.difficultyCalculator.beatmap.hitObjects.sliders > 0) {
-            const fullComboThreshold = maxCombo -
-                0.1 * this.difficultyCalculator.beatmap.hitObjects.sliders;
+        if (this.difficultyAttributes.sliderCount > 0) {
+            const fullComboThreshold = maxCombo - 0.1 * this.difficultyAttributes.sliderCount;
             if (combo < fullComboThreshold) {
                 comboBasedMissCount = Math.min(fullComboThreshold / Math.max(1, combo), this.mode === osuBase.Modes.droid
                     ? // We're clamping miss count because since it's derived from combo, it can
                         // be higher than the amount of objects and that breaks some calculations.
-                        this.difficultyCalculator.objects.length
+                        this.totalHits
                     : // Clamp miss count to maximum amount of possible breaks.
                         this.computedAccuracy.n300 +
                             this.computedAccuracy.n100 +
@@ -1871,8 +1894,16 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         return this._tapPenalty;
     }
     _tapPenalty = 1;
+    difficultyAttributes;
     finalMultiplier = 1.24;
     mode = osuBase.Modes.droid;
+    /**
+     * @param difficultyAttributes The difficulty attributes to calculate.
+     */
+    constructor(difficultyAttributes) {
+        super();
+        this.difficultyAttributes = osuBase.Utils.deepCopy(difficultyAttributes);
+    }
     /**
      * Applies a tap penalty value to this calculator.
      *
@@ -1914,24 +1945,23 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      * Calculates the aim performance value of the beatmap.
      */
     calculateAimValue() {
-        // Global variables
-        const objectCount = this.difficultyCalculator.objects.length;
-        this.aim = this.baseValue(Math.pow(this.difficultyCalculator.aim, 0.8));
+        this.aim = this.baseValue(Math.pow(this.difficultyAttributes.aimDifficulty, 0.8));
         if (this.effectiveMissCount > 0) {
             // Penalize misses by assessing # of misses relative to the total # of objects.
             // Default a 3% reduction for any # of misses.
             this.aim *=
                 0.97 *
-                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), this.effectiveMissCount);
+                    Math.pow(1 -
+                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
         }
         // Combo scaling
         this.aim *= this.comboPenalty;
         // Scale the aim value with slider factor to nerf very likely dropped sliderends.
         this.aim *= this.sliderNerfFactor;
         // Scale the aim value with accuracy.
-        this.aim *= this.computedAccuracy.value(objectCount);
+        this.aim *= this.computedAccuracy.value(this.totalHits);
         // It is also important to consider accuracy difficulty when doing that.
-        const od = this.difficultyCalculator.stats.od;
+        const od = this.difficultyAttributes.overallDifficulty;
         const odScaling = Math.pow(od, 2) / 2500;
         this.aim *= 0.98 + (od >= 0 ? odScaling : -odScaling);
     }
@@ -1939,15 +1969,14 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      * Calculates the tap performance value of the beatmap.
      */
     calculateTapValue() {
-        // Global variables
-        const objectCount = this.difficultyCalculator.objects.length;
-        this.tap = this.baseValue(this.difficultyCalculator.tap);
+        this.tap = this.baseValue(this.difficultyAttributes.tapDifficulty);
         if (this.effectiveMissCount > 0) {
             // Penalize misses by assessing # of misses relative to the total # of objects.
             // Default a 3% reduction for any # of misses.
             this.tap *=
                 0.97 *
-                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+                    Math.pow(1 -
+                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
         }
         // Combo scaling
         this.tap *= this.comboPenalty;
@@ -1955,7 +1984,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         const countGreat = this.computedAccuracy.n300;
         const countOk = this.computedAccuracy.n100;
         const countMeh = this.computedAccuracy.n50;
-        const relevantTotalDiff = objectCount - this.difficultyCalculator.attributes.speedNoteCount;
+        const relevantTotalDiff = this.totalHits - this.difficultyAttributes.speedNoteCount;
         const relevantAccuracy = new osuBase.Accuracy({
             n300: Math.max(0, countGreat - relevantTotalDiff),
             n100: Math.max(0, countOk - Math.max(0, relevantTotalDiff - countGreat)),
@@ -1963,15 +1992,15 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             nmiss: this.effectiveMissCount,
         });
         // Scale the tap value with accuracy and OD.
-        const od = this.difficultyCalculator.stats.od;
+        const od = this.difficultyAttributes.overallDifficulty;
         const odScaling = Math.pow(od, 2) / 750;
         this.tap *=
             (0.95 + (od > 0 ? odScaling : -odScaling)) *
-                Math.pow((this.computedAccuracy.value(objectCount) +
-                    relevantAccuracy.value(this.difficultyCalculator.attributes.speedNoteCount)) /
+                Math.pow((this.computedAccuracy.value(this.totalHits) +
+                    relevantAccuracy.value(this.difficultyAttributes.speedNoteCount)) /
                     2, (14 - Math.max(od, 2.5)) / 2);
         // Scale the tap value with # of 50s to punish doubletapping.
-        this.tap *= Math.pow(0.99, Math.max(0, this.computedAccuracy.n50 - objectCount / 500));
+        this.tap *= Math.pow(0.99, Math.max(0, this.computedAccuracy.n50 - this.totalHits / 500));
         // Scale the tap value with three-fingered penalty.
         this.tap /= this._tapPenalty;
     }
@@ -1979,34 +2008,35 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      * Calculates the accuracy performance value of the beatmap.
      */
     calculateAccuracyValue() {
-        if (this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModRelax)) {
+        if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            this.accuracy = 0;
             return;
         }
-        // Global variables
-        const objectCount = this.difficultyCalculator.objects.length;
-        const ncircles = this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModScoreV2)
-            ? objectCount -
-                this.difficultyCalculator.beatmap.hitObjects.spinners
-            : this.difficultyCalculator.beatmap.hitObjects.circles;
+        const ncircles = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModScoreV2)
+            ? this.totalHits - this.difficultyAttributes.spinnerCount
+            : this.difficultyAttributes.hitCircleCount;
         if (ncircles === 0) {
+            this.accuracy = 0;
             return;
         }
         const realAccuracy = new osuBase.Accuracy({
             ...this.computedAccuracy,
-            n300: this.computedAccuracy.n300 - (objectCount - ncircles),
+            n300: this.computedAccuracy.n300 - (this.totalHits - ncircles),
         });
         // Lots of arbitrary values from testing.
         // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
         this.accuracy =
-            Math.pow(1.4, this.difficultyCalculator.stats.od) *
+            Math.pow(1.4, this.difficultyAttributes.overallDifficulty) *
                 Math.pow(realAccuracy.value(ncircles), 12) *
                 10;
         // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
         this.accuracy *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
         // Scale the accuracy value with rhythm complexity.
         this.accuracy *=
-            1.5 / (1 + Math.exp(-(this.difficultyCalculator.rhythm - 1) / 2));
-        if (this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            1.5 /
+                (1 +
+                    Math.exp(-(this.difficultyAttributes.rhythmDifficulty - 1) / 2));
+        if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
             this.accuracy *= 1.02;
         }
     }
@@ -2014,32 +2044,33 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      * Calculates the flashlight performance value of the beatmap.
      */
     calculateFlashlightValue() {
-        if (!this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+        if (!this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            this.flashlight = 0;
             return;
         }
-        // Global variables
-        const objectCount = this.difficultyCalculator.objects.length;
         this.flashlight =
-            Math.pow(this.difficultyCalculator.flashlight, 1.6) * 25;
+            Math.pow(this.difficultyAttributes.flashlightDifficulty, 1.6) * 25;
         // Combo scaling
         this.flashlight *= this.comboPenalty;
         if (this.effectiveMissCount > 0) {
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             this.flashlight *=
                 0.97 *
-                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+                    Math.pow(1 -
+                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
         }
         // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
         this.flashlight *=
             0.7 +
-                0.1 * Math.min(1, objectCount / 200) +
-                (objectCount > 200
-                    ? 0.2 * Math.min(1, (objectCount - 200) / 200)
+                0.1 * Math.min(1, this.totalHits / 200) +
+                (this.totalHits > 200
+                    ? 0.2 * Math.min(1, (this.totalHits - 200) / 200)
                     : 0);
         // Scale the flashlight value with accuracy slightly.
-        this.flashlight *= 0.5 + this.computedAccuracy.value(objectCount) / 2;
+        this.flashlight *=
+            0.5 + this.computedAccuracy.value(this.totalHits) / 2;
         // It is also important to consider accuracy difficulty when doing that.
-        const od = this.difficultyCalculator.stats.od;
+        const od = this.difficultyAttributes.overallDifficulty;
         const odScaling = Math.pow(od, 2) / 2500;
         this.flashlight *= 0.98 + (od >= 0 ? odScaling : -odScaling);
     }
@@ -2047,25 +2078,25 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      * Calculates the visual performance value of the beatmap.
      */
     calculateVisualValue() {
-        // Global variables
-        const objectCount = this.difficultyCalculator.objects.length;
-        this.visual = Math.pow(this.difficultyCalculator.visual, 1.6) * 22.5;
+        this.visual =
+            Math.pow(this.difficultyAttributes.visualDifficulty, 1.6) * 22.5;
         if (this.effectiveMissCount > 0) {
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             this.visual *=
                 0.97 *
-                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), this.effectiveMissCount);
+                    Math.pow(1 -
+                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
         }
         // Combo scaling
         this.visual *= this.comboPenalty;
         // Scale the visual value with object count to penalize short maps.
         this.visual *= Math.min(1, 1.650668 +
             (0.4845796 - 1.650668) /
-                (1 + Math.pow(objectCount / 817.9306, 1.147469)));
+                (1 + Math.pow(this.totalHits / 817.9306, 1.147469)));
         // Scale the visual value with accuracy harshly.
         this.visual *= Math.pow(this.computedAccuracy.value(), 8);
         // It is also important to consider accuracy difficulty when doing that.
-        const od = this.difficultyCalculator.stats.od;
+        const od = this.difficultyAttributes.overallDifficulty;
         const odScaling = Math.pow(od, 2) / 2500;
         this.visual *= 0.98 + (od >= 0 ? odScaling : -odScaling);
     }
@@ -2620,6 +2651,21 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
      * The flashlight star rating of the beatmap.
      */
     flashlight = 0;
+    attributes = {
+        speedDifficulty: 0,
+        mods: [],
+        starRating: 0,
+        maxCombo: 0,
+        aimDifficulty: 0,
+        flashlightDifficulty: 0,
+        speedNoteCount: 0,
+        sliderFactor: 0,
+        approachRate: 0,
+        overallDifficulty: 0,
+        hitCircleCount: 0,
+        sliderCount: 0,
+        spinnerCount: 0,
+    };
     difficultyMultiplier = 0.0675;
     mode = osuBase.Modes.osu;
     /**
@@ -2734,6 +2780,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.aim *= 0.9;
         }
+        this.attributes.aimDifficulty = this.aim;
     }
     /**
      * Called after speed skill calculation.
@@ -2742,7 +2789,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
      */
     postCalculateSpeed(speedSkill) {
         this.strainPeaks.speed = speedSkill.strainPeaks;
-        this.speed = this.starValue(speedSkill.difficultyValue());
+        this.speed = this.attributes.speedDifficulty = this.starValue(speedSkill.difficultyValue());
     }
     /**
      * Calculates speed-related attributes.
@@ -2768,6 +2815,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.flashlight *= 0.7;
         }
+        this.attributes.flashlightDifficulty = this.flashlight;
     }
 }
 
@@ -2832,8 +2880,16 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
      * The flashlight performance value.
      */
     flashlight = 0;
+    difficultyAttributes;
     finalMultiplier = 1.14;
     mode = osuBase.Modes.osu;
+    /**
+     * @param difficultyAttributes The difficulty attributes to calculate.
+     */
+    constructor(difficultyAttributes) {
+        super();
+        this.difficultyAttributes = osuBase.Utils.deepCopy(difficultyAttributes);
+    }
     calculateValues() {
         this.calculateAimValue();
         this.calculateSpeedValue();
@@ -2851,25 +2907,24 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
      * Calculates the aim performance value of the beatmap.
      */
     calculateAimValue() {
-        // Global variables
-        const objectCount = this.difficultyCalculator.objects.length;
-        const calculatedAR = this.difficultyCalculator.stats.ar;
-        this.aim = this.baseValue(this.difficultyCalculator.aim);
+        this.aim = this.baseValue(this.difficultyAttributes.aimDifficulty);
         // Longer maps are worth more
-        let lengthBonus = 0.95 + 0.4 * Math.min(1, objectCount / 2000);
-        if (objectCount > 2000) {
-            lengthBonus += Math.log10(objectCount / 2000) * 0.5;
+        let lengthBonus = 0.95 + 0.4 * Math.min(1, this.totalHits / 2000);
+        if (this.totalHits > 2000) {
+            lengthBonus += Math.log10(this.totalHits / 2000) * 0.5;
         }
         this.aim *= lengthBonus;
         if (this.effectiveMissCount > 0) {
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             this.aim *=
                 0.97 *
-                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), this.effectiveMissCount);
+                    Math.pow(1 -
+                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
         }
         // Combo scaling
         this.aim *= this.comboPenalty;
-        if (!this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModRelax)) {
+        const calculatedAR = this.difficultyAttributes.approachRate;
+        if (!this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
             // AR scaling
             let arFactor = 0;
             if (calculatedAR > 10.33) {
@@ -2882,57 +2937,56 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             this.aim *= 1 + arFactor * lengthBonus;
         }
         // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-        if (this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModHidden)) {
+        if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHidden)) {
             this.aim *= 1 + 0.04 * (12 - calculatedAR);
         }
         // Scale the aim value with slider factor to nerf very likely dropped sliderends.
         this.aim *= this.sliderNerfFactor;
         // Scale the aim value with accuracy.
-        this.aim *= this.computedAccuracy.value(objectCount);
+        this.aim *= this.computedAccuracy.value(this.totalHits);
         // It is also important to consider accuracy difficulty when doing that.
-        const odScaling = Math.pow(this.difficultyCalculator.stats.od, 2) / 2500;
+        const odScaling = Math.pow(this.difficultyAttributes.overallDifficulty, 2) / 2500;
         this.aim *= 0.98 + odScaling;
     }
     /**
      * Calculates the speed performance value of the beatmap.
      */
     calculateSpeedValue() {
-        if (this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModRelax)) {
+        if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.speed = 0;
             return;
         }
         // Global variables
-        const objectCount = this.difficultyCalculator.objects.length;
-        const calculatedAR = this.difficultyCalculator.stats.ar;
-        const n50 = this.computedAccuracy.n50;
-        this.speed = this.baseValue(this.difficultyCalculator.speed);
+        this.speed = this.baseValue(this.difficultyAttributes.speedDifficulty);
         // Longer maps are worth more
-        let lengthBonus = 0.95 + 0.4 * Math.min(1, objectCount / 2000);
-        if (objectCount > 2000) {
-            lengthBonus += Math.log10(objectCount / 2000) * 0.5;
+        let lengthBonus = 0.95 + 0.4 * Math.min(1, this.totalHits / 2000);
+        if (this.totalHits > 2000) {
+            lengthBonus += Math.log10(this.totalHits / 2000) * 0.5;
         }
         this.speed *= lengthBonus;
         if (this.effectiveMissCount > 0) {
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             this.speed *=
                 0.97 *
-                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+                    Math.pow(1 -
+                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
         }
         // Combo scaling
         this.speed *= this.comboPenalty;
         // AR scaling
+        const calculatedAR = this.difficultyAttributes.approachRate;
         if (calculatedAR > 10.33) {
             // Buff for longer maps with high AR.
             this.speed *= 1 + 0.3 * (calculatedAR - 10.33) * lengthBonus;
         }
-        if (this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModHidden)) {
+        if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHidden)) {
             this.speed *= 1 + 0.04 * (12 - calculatedAR);
         }
         // Calculate accuracy assuming the worst case scenario.
         const countGreat = this.computedAccuracy.n300;
         const countOk = this.computedAccuracy.n100;
         const countMeh = this.computedAccuracy.n50;
-        const relevantTotalDiff = objectCount - this.difficultyCalculator.attributes.speedNoteCount;
+        const relevantTotalDiff = this.totalHits - this.difficultyAttributes.speedNoteCount;
         const relevantAccuracy = new osuBase.Accuracy({
             n300: Math.max(0, countGreat - relevantTotalDiff),
             n100: Math.max(0, countOk - Math.max(0, relevantTotalDiff - countGreat)),
@@ -2941,45 +2995,48 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         });
         // Scale the speed value with accuracy and OD.
         this.speed *=
-            (0.95 + Math.pow(this.difficultyCalculator.stats.od, 2) / 750) *
-                Math.pow((this.computedAccuracy.value(objectCount) +
+            (0.95 +
+                Math.pow(this.difficultyAttributes.overallDifficulty, 2) /
+                    750) *
+                Math.pow((this.computedAccuracy.value(this.totalHits) +
                     relevantAccuracy.value()) /
-                    2, (14.5 - Math.max(this.difficultyCalculator.stats.od, 8)) / 2);
+                    2, (14.5 -
+                    Math.max(this.difficultyAttributes.overallDifficulty, 8)) /
+                    2);
         // Scale the speed value with # of 50s to punish doubletapping.
-        this.speed *= Math.pow(0.99, Math.max(0, n50 - objectCount / 500));
+        this.speed *= Math.pow(0.99, Math.max(0, this.computedAccuracy.n50 - this.totalHits / 500));
     }
     /**
      * Calculates the accuracy performance value of the beatmap.
      */
     calculateAccuracyValue() {
-        if (this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModRelax)) {
+        if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            this.accuracy = 0;
             return;
         }
-        // Global variables
-        const nobjects = this.difficultyCalculator.objects.length;
-        const ncircles = this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModScoreV2)
-            ? nobjects - this.difficultyCalculator.beatmap.hitObjects.spinners
-            : this.difficultyCalculator.beatmap.hitObjects.circles;
+        const ncircles = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModScoreV2)
+            ? this.totalHits - this.difficultyAttributes.spinnerCount
+            : this.difficultyAttributes.hitCircleCount;
         if (ncircles === 0) {
+            this.accuracy = 0;
             return;
         }
         const realAccuracy = new osuBase.Accuracy({
             ...this.computedAccuracy,
-            n300: this.computedAccuracy.n300 -
-                (this.difficultyCalculator.objects.length - ncircles),
+            n300: this.computedAccuracy.n300 - (this.totalHits - ncircles),
         });
         // Lots of arbitrary values from testing.
         // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
         this.accuracy =
-            Math.pow(1.52163, this.difficultyCalculator.stats.od) *
+            Math.pow(1.52163, this.difficultyAttributes.overallDifficulty) *
                 Math.pow(realAccuracy.value(ncircles), 24) *
                 2.83;
         // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
         this.accuracy *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
-        if (this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModHidden)) {
+        if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHidden)) {
             this.accuracy *= 1.08;
         }
-        if (this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+        if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
             this.accuracy *= 1.02;
         }
     }
@@ -2987,32 +3044,34 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
      * Calculates the flashlight performance value of the beatmap.
      */
     calculateFlashlightValue() {
-        if (!this.difficultyCalculator.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+        if (!this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
+            this.flashlight = 0;
             return;
         }
         // Global variables
-        const objectCount = this.difficultyCalculator.objects.length;
         this.flashlight =
-            Math.pow(this.difficultyCalculator.flashlight, 2) * 25;
+            Math.pow(this.difficultyAttributes.flashlightDifficulty, 2) * 25;
         // Combo scaling
         this.flashlight *= this.comboPenalty;
         if (this.effectiveMissCount > 0) {
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             this.flashlight *=
                 0.97 *
-                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+                    Math.pow(1 -
+                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
         }
         // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
         this.flashlight *=
             0.7 +
-                0.1 * Math.min(1, objectCount / 200) +
-                (objectCount > 200
-                    ? 0.2 * Math.min(1, (objectCount - 200) / 200)
+                0.1 * Math.min(1, this.totalHits / 200) +
+                (this.totalHits > 200
+                    ? 0.2 * Math.min(1, (this.totalHits - 200) / 200)
                     : 0);
         // Scale the flashlight value with accuracy slightly.
-        this.flashlight *= 0.5 + this.computedAccuracy.value(objectCount) / 2;
+        this.flashlight *=
+            0.5 + this.computedAccuracy.value(this.totalHits) / 2;
         // It is also important to consider accuracy difficulty when doing that.
-        const odScaling = Math.pow(this.difficultyCalculator.stats.od, 2) / 2500;
+        const odScaling = Math.pow(this.difficultyAttributes.overallDifficulty, 2) / 2500;
         this.flashlight *= 0.98 + odScaling;
     }
     toString() {