@rian8337/osu-difficulty-calculator 4.0.0-beta.86 → 4.0.0-beta.88

package/dist/index.js

@@ -409,7 +409,7 @@ class DifficultyHitObject {
             this.lazyEndPosition = this.object.stackedPosition;
             // Stop here if the slider has too short duration, allowing the player to essentially
             // complete the slider without movement, making travel distance and time irrelevant.
-            if (osuBase.Precision.almostEqualsNumber(this.object.startTime, this.object.endTime)) {
+            if (osuBase.Precision.almostEquals(this.object.startTime, this.object.endTime)) {
                 return;
             }
         }
@@ -1919,15 +1919,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         attributes.hitCircleCount = beatmap.hitObjects.circles;
         attributes.sliderCount = beatmap.hitObjects.sliders;
         attributes.spinnerCount = beatmap.hitObjects.spinners;
-        let greatWindow;
-        if (attributes.mods.has(osuBase.ModPrecise)) {
-            greatWindow = new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od)
-                .greatWindow;
-        }
-        else {
-            greatWindow = new osuBase.DroidHitWindow(beatmap.difficulty.od).greatWindow;
-        }
-        attributes.overallDifficulty = osuBase.OsuHitWindow.greatWindowToOD(greatWindow / attributes.clockRate);
+        attributes.overallDifficulty = beatmap.difficulty.od;
         this.populateAimAttributes(attributes, skills, objects);
         this.populateTapAttributes(attributes, skills, objects);
         this.populateRhythmAttributes(attributes, skills);
@@ -2162,8 +2154,16 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             attributes.readingDifficulty *= 0.4;
         }
         // Consider accuracy difficulty.
-        const ratingMultiplier = 0.75 +
-            Math.pow(Math.max(0, attributes.overallDifficulty), 2.2) / 800;
+        let greatWindow;
+        if (attributes.mods.has(osuBase.ModPrecise)) {
+            greatWindow = new osuBase.PreciseDroidHitWindow(attributes.overallDifficulty).greatWindow;
+        }
+        else {
+            greatWindow = new osuBase.DroidHitWindow(attributes.overallDifficulty)
+                .greatWindow;
+        }
+        const overallDifficulty = osuBase.UnadjustedOsuHitWindow.greatWindowToOD(greatWindow / attributes.clockRate);
+        const ratingMultiplier = 0.75 + Math.pow(Math.max(0, overallDifficulty), 2.2) / 800;
         attributes.readingDifficulty *= Math.sqrt(ratingMultiplier);
     }
     /**
@@ -2687,7 +2687,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return Number.POSITIVE_INFINITY;
         }
         const { clockRate } = this.difficultyAttributes;
-        const hitWindow = this.getConvertedHitWindow();
+        const hitWindow = this.getHitWindow();
         const hitWindow300 = hitWindow.greatWindow / clockRate;
         const hitWindow100 = hitWindow.okWindow / clockRate;
         const hitWindow50 = hitWindow.mehWindow / clockRate;
@@ -2756,7 +2756,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return Number.POSITIVE_INFINITY;
         }
         const { clockRate, speedNoteCount } = this.difficultyAttributes;
-        const hitWindow = this.getConvertedHitWindow();
+        const hitWindow = this.getHitWindow();
         const hitWindow300 = hitWindow.greatWindow / clockRate;
         const hitWindow100 = hitWindow.okWindow / clockRate;
         const hitWindow50 = hitWindow.mehWindow / clockRate;
@@ -2842,14 +2842,11 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         const t = 1 - osuBase.Interpolation.reverseLerp(this.tapDeviation, 25, 30);
         return osuBase.Interpolation.lerp(adjustedTapValue, tapValue, t) / tapValue;
     }
-    getConvertedHitWindow() {
-        const hitWindow300 = new osuBase.OsuHitWindow(this.difficultyAttributes.overallDifficulty).greatWindow;
-        if (this.mods.has(osuBase.ModPrecise)) {
-            return new osuBase.PreciseDroidHitWindow(osuBase.PreciseDroidHitWindow.greatWindowToOD(hitWindow300 * this.difficultyAttributes.clockRate));
-        }
-        else {
-            return new osuBase.DroidHitWindow(osuBase.DroidHitWindow.greatWindowToOD(hitWindow300 * this.difficultyAttributes.clockRate));
-        }
+    getHitWindow() {
+        const { overallDifficulty } = this.difficultyAttributes;
+        return this.mods.has(osuBase.ModPrecise)
+            ? new osuBase.PreciseDroidHitWindow(overallDifficulty)
+            : new osuBase.DroidHitWindow(overallDifficulty);
     }
     toString() {
         return (this.total.toFixed(2) +
@@ -3182,6 +3179,185 @@ class OsuDifficultyAttributes extends DifficultyAttributes {
     }
 }
 
+class OsuRatingCalculator {
+    constructor(mods, totalHits, approachRate, overallDifficulty, mechanicalDifficultyRating, sliderFactor) {
+        this.mods = mods;
+        this.totalHits = totalHits;
+        this.approachRate = approachRate;
+        this.overallDifficulty = overallDifficulty;
+        this.mechanicalDifficultyRating = mechanicalDifficultyRating;
+        this.sliderFactor = sliderFactor;
+    }
+    computeAimRating(aimDifficultyValue) {
+        if (this.mods.has(osuBase.ModAutopilot)) {
+            return 0;
+        }
+        let aimRating = OsuRatingCalculator.calculateDifficultyRating(aimDifficultyValue);
+        if (this.mods.has(osuBase.ModTouchDevice)) {
+            aimRating = Math.pow(aimRating, 0.8);
+        }
+        if (this.mods.has(osuBase.ModRelax)) {
+            aimRating *= 0.9;
+        }
+        if (this.mods.has(osuBase.ModMagnetised)) {
+            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
+            aimRating *= 1 - magnetisedStrength;
+        }
+        let ratingMultiplier = 1;
+        const approachRateLengthBonus = 0.95 +
+            0.4 * Math.min(1, this.totalHits / 2000) +
+            (this.totalHits > 2000
+                ? Math.log10(this.totalHits / 2000) * 0.5
+                : 0);
+        let approachRateFactor = 0;
+        if (this.approachRate > 10.33) {
+            approachRateFactor = 0.3 * (this.approachRate - 10.33);
+        }
+        else if (this.approachRate < 8) {
+            approachRateFactor = 0.05 * (8 - this.approachRate);
+        }
+        if (this.mods.has(osuBase.ModRelax)) {
+            approachRateFactor = 0;
+        }
+        // Buff for longer beatmaps with high AR.
+        ratingMultiplier += approachRateFactor * approachRateLengthBonus;
+        if (this.mods.has(osuBase.ModHidden)) {
+            const visibilityFactor = this.calculateAimVisibilityFactor();
+            ratingMultiplier += OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.approachRate, visibilityFactor, this.sliderFactor);
+        }
+        // It is important to consider accuracy difficulty when scaling with accuracy.
+        ratingMultiplier *=
+            0.98 + Math.pow(Math.max(0, this.overallDifficulty), 2) / 2500;
+        return aimRating * Math.cbrt(ratingMultiplier);
+    }
+    computeSpeedRating(speedDifficultyValue) {
+        if (this.mods.has(osuBase.ModRelax)) {
+            return 0;
+        }
+        let speedRating = OsuRatingCalculator.calculateDifficultyRating(speedDifficultyValue);
+        if (this.mods.has(osuBase.ModAutopilot)) {
+            speedRating *= 0.5;
+        }
+        if (this.mods.has(osuBase.ModMagnetised)) {
+            // Reduce speed rating because of the distance scaling, with maximum reduction being 0.7.
+            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
+            speedRating *= 1 - magnetisedStrength * 0.3;
+        }
+        let ratingMultiplier = 1;
+        const approachRateLengthBonus = 0.95 +
+            0.4 * Math.min(1, this.totalHits / 2000) +
+            (this.totalHits > 2000
+                ? Math.log10(this.totalHits / 2000) * 0.5
+                : 0);
+        let approachRateFactor = 0;
+        if (this.approachRate > 10.33) {
+            approachRateFactor = 0.3 * (this.approachRate - 10.33);
+        }
+        if (this.mods.has(osuBase.ModAutopilot)) {
+            approachRateFactor = 0;
+        }
+        // Buff for longer beatmaps with high AR.
+        ratingMultiplier += approachRateFactor * approachRateLengthBonus;
+        if (this.mods.has(osuBase.ModHidden)) {
+            const visibilityFactor = this.calculateSpeedVisibilityFactor();
+            ratingMultiplier += OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.approachRate, visibilityFactor, this.sliderFactor);
+        }
+        ratingMultiplier *=
+            0.95 + Math.pow(Math.max(0, this.overallDifficulty), 2) / 750;
+        return speedRating * Math.cbrt(ratingMultiplier);
+    }
+    computeFlashlightRating(flashlightDifficultyValue) {
+        if (!this.mods.has(osuBase.ModFlashlight)) {
+            return 0;
+        }
+        let flashlightRating = OsuRatingCalculator.calculateDifficultyRating(flashlightDifficultyValue);
+        if (this.mods.has(osuBase.ModTouchDevice)) {
+            flashlightRating = Math.pow(flashlightRating, 0.8);
+        }
+        if (this.mods.has(osuBase.ModRelax)) {
+            flashlightRating *= 0.7;
+        }
+        else if (this.mods.has(osuBase.ModAutopilot)) {
+            flashlightRating *= 0.4;
+        }
+        if (this.mods.has(osuBase.ModMagnetised)) {
+            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
+            flashlightRating *= 1 - magnetisedStrength;
+        }
+        if (this.mods.has(osuBase.ModDeflate)) {
+            const deflateInitialScale = this.mods.get(osuBase.ModDeflate).startScale.value;
+            flashlightRating *= osuBase.MathUtils.clamp(osuBase.Interpolation.reverseLerp(deflateInitialScale, 11, 1), 0.1, 1);
+        }
+        let ratingMultiplier = 1;
+        // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
+        ratingMultiplier *=
+            0.7 +
+                0.1 * Math.min(1, this.totalHits / 200) +
+                (this.totalHits > 200
+                    ? 0.2 * Math.min(1, (this.totalHits - 200) / 200)
+                    : 0);
+        // It is important to consider accuracy difficulty when scaling with accuracy.
+        ratingMultiplier *=
+            0.98 + Math.pow(Math.max(0, this.overallDifficulty), 2) / 2500;
+        return flashlightRating * Math.sqrt(ratingMultiplier);
+    }
+    calculateAimVisibilityFactor() {
+        const approachRateFactorEndpoint = 11.5;
+        const mechanicalDifficultyFactor = osuBase.Interpolation.reverseLerp(this.mechanicalDifficultyRating, 5, 10);
+        const approachRateFactorStartingPoint = osuBase.Interpolation.lerp(9, 10.33, mechanicalDifficultyFactor);
+        return osuBase.Interpolation.reverseLerp(this.approachRate, approachRateFactorEndpoint, approachRateFactorStartingPoint);
+    }
+    calculateSpeedVisibilityFactor() {
+        const approachRateFactorEndpoint = 11.5;
+        const mechanicalDifficultyFactor = osuBase.Interpolation.reverseLerp(this.mechanicalDifficultyRating, 5, 10);
+        const approachRateFactorStartingPoint = osuBase.Interpolation.lerp(10, 10.33, mechanicalDifficultyFactor);
+        return osuBase.Interpolation.reverseLerp(this.approachRate, approachRateFactorEndpoint, approachRateFactorStartingPoint);
+    }
+    /**
+     * Calculates a visibility bonus that is applicable to Hidden and Traceable.
+     *
+     * @param mods The mods applied to the calculation.
+     * @param approachRate The approach rate of the beatmap.
+     * @param visibilityFactor The visibility factor to apply.
+     * @param sliderFactor The slider factor to apply.
+     * @returns The visibility bonus multiplier.
+     */
+    static calculateVisibilityBonus(mods, approachRate, visibilityFactor = 1, sliderFactor = 1) {
+        var _a, _b;
+        const isAlwaysPartiallyVisible = (_b = (_a = mods.get(osuBase.ModHidden)) === null || _a === void 0 ? void 0 : _a.onlyFadeApproachCircles.value) !== null && _b !== void 0 ? _b : mods.has(osuBase.ModTraceable);
+        // Start from normal curve, rewarding lower AR up to AR 7.
+        // Traceable forcefully requires a lower reading bonus for now as it is post-applied in pp, which make
+        // it multiplicative with the regular AR bonuses.
+        // This means it has an advantage over Hidden, so we decrease the multiplier to compensate.
+        // This should be removed once we are able to apply Traceable bonuses in star rating (requires real-time
+        // difficulty calculations being possible).
+        let readingBonus = (isAlwaysPartiallyVisible ? 0.025 : 0.04) *
+            (12 - Math.max(approachRate, 7));
+        readingBonus *= visibilityFactor;
+        // We want to reward slideraim on low AR less.
+        const sliderVisibilityFactor = Math.pow(sliderFactor, 3);
+        // For AR up to 0, reduce reward for very low ARs when object is visible.
+        if (approachRate < 7) {
+            readingBonus +=
+                (isAlwaysPartiallyVisible ? 0.02 : 0.045) *
+                    (7 - Math.max(approachRate, 0)) *
+                    sliderVisibilityFactor;
+        }
+        // Starting from AR 0, cap values so they won't grow to infinity.
+        if (approachRate < 0) {
+            readingBonus +=
+                (isAlwaysPartiallyVisible ? 0.01 : 0.1) *
+                    (1 - Math.pow(1.5, approachRate)) *
+                    sliderVisibilityFactor;
+        }
+        return readingBonus;
+    }
+    static calculateDifficultyRating(difficultyValue) {
+        return Math.sqrt(difficultyValue) * this.difficultyMultiplier;
+    }
+}
+OsuRatingCalculator.difficultyMultiplier = 0.0675;
+
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
  */
@@ -3459,185 +3635,6 @@ class OsuSpeed extends OsuSkill {
     }
 }
 
-class OsuRatingCalculator {
-    constructor(mods, totalHits, approachRate, overallDifficulty, mechanicalDifficultyRating, sliderFactor) {
-        this.mods = mods;
-        this.totalHits = totalHits;
-        this.approachRate = approachRate;
-        this.overallDifficulty = overallDifficulty;
-        this.mechanicalDifficultyRating = mechanicalDifficultyRating;
-        this.sliderFactor = sliderFactor;
-    }
-    computeAimRating(aimDifficultyValue) {
-        if (this.mods.has(osuBase.ModAutopilot)) {
-            return 0;
-        }
-        let aimRating = OsuRatingCalculator.calculateDifficultyRating(aimDifficultyValue);
-        if (this.mods.has(osuBase.ModTouchDevice)) {
-            aimRating = Math.pow(aimRating, 0.8);
-        }
-        if (this.mods.has(osuBase.ModRelax)) {
-            aimRating *= 0.9;
-        }
-        if (this.mods.has(osuBase.ModMagnetised)) {
-            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
-            aimRating *= 1 - magnetisedStrength;
-        }
-        let ratingMultiplier = 1;
-        const approachRateLengthBonus = 0.95 +
-            0.4 * Math.min(1, this.totalHits / 2000) +
-            (this.totalHits > 2000
-                ? Math.log10(this.totalHits / 2000) * 0.5
-                : 0);
-        let approachRateFactor = 0;
-        if (this.approachRate > 10.33) {
-            approachRateFactor = 0.3 * (this.approachRate - 10.33);
-        }
-        else if (this.approachRate < 8) {
-            approachRateFactor = 0.05 * (8 - this.approachRate);
-        }
-        if (this.mods.has(osuBase.ModRelax)) {
-            approachRateFactor = 0;
-        }
-        // Buff for longer beatmaps with high AR.
-        ratingMultiplier += approachRateFactor * approachRateLengthBonus;
-        if (this.mods.has(osuBase.ModHidden)) {
-            const visibilityFactor = this.calculateAimVisibilityFactor();
-            ratingMultiplier += OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.approachRate, visibilityFactor, this.sliderFactor);
-        }
-        // It is important to consider accuracy difficulty when scaling with accuracy.
-        ratingMultiplier *=
-            0.98 + Math.pow(Math.max(0, this.overallDifficulty), 2) / 2500;
-        return aimRating * Math.cbrt(ratingMultiplier);
-    }
-    computeSpeedRating(speedDifficultyValue) {
-        if (this.mods.has(osuBase.ModRelax)) {
-            return 0;
-        }
-        let speedRating = OsuRatingCalculator.calculateDifficultyRating(speedDifficultyValue);
-        if (this.mods.has(osuBase.ModAutopilot)) {
-            speedRating *= 0.5;
-        }
-        if (this.mods.has(osuBase.ModMagnetised)) {
-            // Reduce speed rating because of the distance scaling, with maximum reduction being 0.7.
-            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
-            speedRating *= 1 - magnetisedStrength * 0.3;
-        }
-        let ratingMultiplier = 1;
-        const approachRateLengthBonus = 0.95 +
-            0.4 * Math.min(1, this.totalHits / 2000) +
-            (this.totalHits > 2000
-                ? Math.log10(this.totalHits / 2000) * 0.5
-                : 0);
-        let approachRateFactor = 0;
-        if (this.approachRate > 10.33) {
-            approachRateFactor = 0.3 * (this.approachRate - 10.33);
-        }
-        if (this.mods.has(osuBase.ModAutopilot)) {
-            approachRateFactor = 0;
-        }
-        // Buff for longer beatmaps with high AR.
-        ratingMultiplier += approachRateFactor * approachRateLengthBonus;
-        if (this.mods.has(osuBase.ModHidden)) {
-            const visibilityFactor = this.calculateSpeedVisibilityFactor();
-            ratingMultiplier += OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.approachRate, visibilityFactor, this.sliderFactor);
-        }
-        ratingMultiplier *=
-            0.95 + Math.pow(Math.max(0, this.overallDifficulty), 2) / 750;
-        return speedRating * Math.cbrt(ratingMultiplier);
-    }
-    computeFlashlightRating(flashlightDifficultyValue) {
-        if (!this.mods.has(osuBase.ModFlashlight)) {
-            return 0;
-        }
-        let flashlightRating = OsuRatingCalculator.calculateDifficultyRating(flashlightDifficultyValue);
-        if (this.mods.has(osuBase.ModTouchDevice)) {
-            flashlightRating = Math.pow(flashlightRating, 0.8);
-        }
-        if (this.mods.has(osuBase.ModRelax)) {
-            flashlightRating *= 0.7;
-        }
-        else if (this.mods.has(osuBase.ModAutopilot)) {
-            flashlightRating *= 0.4;
-        }
-        if (this.mods.has(osuBase.ModMagnetised)) {
-            const magnetisedStrength = this.mods.get(osuBase.ModMagnetised).attractionStrength.value;
-            flashlightRating *= 1 - magnetisedStrength;
-        }
-        if (this.mods.has(osuBase.ModDeflate)) {
-            const deflateInitialScale = this.mods.get(osuBase.ModDeflate).startScale.value;
-            flashlightRating *= osuBase.MathUtils.clamp(osuBase.Interpolation.reverseLerp(deflateInitialScale, 11, 1), 0.1, 1);
-        }
-        let ratingMultiplier = 1;
-        // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
-        ratingMultiplier *=
-            0.7 +
-                0.1 * Math.min(1, this.totalHits / 200) +
-                (this.totalHits > 200
-                    ? 0.2 * Math.min(1, (this.totalHits - 200) / 200)
-                    : 0);
-        // It is important to consider accuracy difficulty when scaling with accuracy.
-        ratingMultiplier *=
-            0.98 + Math.pow(Math.max(0, this.overallDifficulty), 2) / 2500;
-        return flashlightRating * Math.sqrt(ratingMultiplier);
-    }
-    calculateAimVisibilityFactor() {
-        const approachRateFactorEndpoint = 11.5;
-        const mechanicalDifficultyFactor = osuBase.Interpolation.reverseLerp(this.mechanicalDifficultyRating, 5, 10);
-        const approachRateFactorStartingPoint = osuBase.Interpolation.lerp(9, 10.33, mechanicalDifficultyFactor);
-        return osuBase.Interpolation.reverseLerp(this.approachRate, approachRateFactorEndpoint, approachRateFactorStartingPoint);
-    }
-    calculateSpeedVisibilityFactor() {
-        const approachRateFactorEndpoint = 11.5;
-        const mechanicalDifficultyFactor = osuBase.Interpolation.reverseLerp(this.mechanicalDifficultyRating, 5, 10);
-        const approachRateFactorStartingPoint = osuBase.Interpolation.lerp(10, 10.33, mechanicalDifficultyFactor);
-        return osuBase.Interpolation.reverseLerp(this.approachRate, approachRateFactorEndpoint, approachRateFactorStartingPoint);
-    }
-    /**
-     * Calculates a visibility bonus that is applicable to Hidden and Traceable.
-     *
-     * @param mods The mods applied to the calculation.
-     * @param approachRate The approach rate of the beatmap.
-     * @param visibilityFactor The visibility factor to apply.
-     * @param sliderFactor The slider factor to apply.
-     * @returns The visibility bonus multiplier.
-     */
-    static calculateVisibilityBonus(mods, approachRate, visibilityFactor = 1, sliderFactor = 1) {
-        var _a, _b;
-        const isAlwaysPartiallyVisible = (_b = (_a = mods.get(osuBase.ModHidden)) === null || _a === void 0 ? void 0 : _a.onlyFadeApproachCircles.value) !== null && _b !== void 0 ? _b : mods.has(osuBase.ModTraceable);
-        // Start from normal curve, rewarding lower AR up to AR 7.
-        // Traceable forcefully requires a lower reading bonus for now as it is post-applied in pp, which make
-        // it multiplicative with the regular AR bonuses.
-        // This means it has an advantage over Hidden, so we decrease the multiplier to compensate.
-        // This should be removed once we are able to apply Traceable bonuses in star rating (requires real-time
-        // difficulty calculations being possible).
-        let readingBonus = (isAlwaysPartiallyVisible ? 0.025 : 0.04) *
-            (12 - Math.max(approachRate, 7));
-        readingBonus *= visibilityFactor;
-        // We want to reward slideraim on low AR less.
-        const sliderVisibilityFactor = Math.pow(sliderFactor, 3);
-        // For AR up to 0, reduce reward for very low ARs when object is visible.
-        if (approachRate < 7) {
-            readingBonus +=
-                (isAlwaysPartiallyVisible ? 0.02 : 0.045) *
-                    (7 - Math.max(approachRate, 0)) *
-                    sliderVisibilityFactor;
-        }
-        // Starting from AR 0, cap values so they won't grow to infinity.
-        if (approachRate < 0) {
-            readingBonus +=
-                (isAlwaysPartiallyVisible ? 0.01 : 0.1) *
-                    (1 - Math.pow(1.5, approachRate)) *
-                    sliderVisibilityFactor;
-        }
-        return readingBonus;
-    }
-    static calculateDifficultyRating(difficultyValue) {
-        return Math.sqrt(difficultyValue) * this.difficultyMultiplier;
-    }
-}
-OsuRatingCalculator.difficultyMultiplier = 0.0675;
-
 /**
  * A performance points calculator that calculates performance points for osu!standard gamemode.
  */
@@ -3660,6 +3657,11 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
          * The flashlight performance value.
          */
         this.flashlight = 0;
+        this.greatWindow = 0;
+        this.okWindow = 0;
+        this.mehWindow = 0;
+        this.approachRate = 0;
+        this.overallDifficulty = 0;
         this._effectiveMissCount = 0;
         this.speedDeviation = 0;
     }
@@ -3672,16 +3674,15 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
     calculateValues() {
         this._effectiveMissCount = osuBase.MathUtils.clamp(this.calculateComboBasedEstimatedMissCount(), this.computedAccuracy.nmiss, this.totalHits);
         let { finalMultiplier } = OsuPerformanceCalculator;
+        const { spinnerCount, approachRate: ar, overallDifficulty: od, clockRate, } = this.difficultyAttributes;
         if (this.mods.has(osuBase.ModNoFail)) {
             finalMultiplier *= Math.max(0.9, 1 - 0.02 * this._effectiveMissCount);
         }
         if (this.mods.has(osuBase.ModSpunOut)) {
             finalMultiplier *=
-                1 -
-                    Math.pow(this.difficultyAttributes.spinnerCount / this.totalHits, 0.85);
+                1 - Math.pow(spinnerCount / this.totalHits, 0.85);
         }
         if (this.mods.has(osuBase.ModRelax)) {
-            const { overallDifficulty: od } = this.difficultyAttributes;
             // Graph: https://www.desmos.com/calculator/vspzsop6td
             // We use OD13.3 as maximum since it's the value at which great hit window becomes 0.
             const n100Multiplier = 0.75 * Math.max(0, od > 0 ? 1 - od / 13.33 : 1);
@@ -3692,6 +3693,14 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                 this.computedAccuracy.n100 * n100Multiplier +
                 this.computedAccuracy.n50 * n50Multiplier, this.totalHits);
         }
+        const hitWindow = new osuBase.OsuHitWindow(od);
+        this.greatWindow = hitWindow.greatWindow / clockRate;
+        this.okWindow = hitWindow.okWindow / clockRate;
+        this.mehWindow = hitWindow.mehWindow / clockRate;
+        this.approachRate =
+            OsuDifficultyCalculator.calculateRateAdjustedApproachRate(ar, clockRate);
+        this.overallDifficulty =
+            OsuDifficultyCalculator.calculateRateAdjustedOverallDifficulty(od, clockRate);
         this.speedDeviation = this.calculateSpeedDeviation();
         this.aim = this.calculateAimValue();
         this.speed = this.calculateSpeedValue();
@@ -3759,7 +3768,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         else if (this.mods.has(osuBase.ModTraceable)) {
             aimValue *=
                 1 +
-                    OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.difficultyAttributes.approachRate, undefined, this.difficultyAttributes.sliderFactor);
+                    OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.approachRate, undefined, this.difficultyAttributes.sliderFactor);
         }
         // Scale the aim value with accuracy.
         aimValue *= this.computedAccuracy.value();
@@ -3794,7 +3803,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         else if (this.mods.has(osuBase.ModTraceable)) {
             speedValue *=
                 1 +
-                    OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.difficultyAttributes.approachRate, undefined, this.difficultyAttributes.sliderFactor);
+                    OsuRatingCalculator.calculateVisibilityBonus(this.mods, this.approachRate, undefined, this.difficultyAttributes.sliderFactor);
         }
         // Calculate accuracy assuming the worst case scenario.
         const countGreat = this.computedAccuracy.n300;
@@ -3812,7 +3821,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                 { n300: 0, nobjects: 1 });
         speedValue *= this.calculateSpeedHighDeviationNerf();
         // Scale the speed value with accuracy and OD.
-        speedValue *= Math.pow((this.computedAccuracy.value() + relevantAccuracy.value()) / 2, (14.5 - this.difficultyAttributes.overallDifficulty) / 2);
+        speedValue *= Math.pow((this.computedAccuracy.value() + relevantAccuracy.value()) / 2, (14.5 - this.overallDifficulty) / 2);
         return speedValue;
     }
     /**
@@ -3831,7 +3840,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         const realAccuracy = new osuBase.Accuracy(Object.assign(Object.assign({}, this.computedAccuracy), { n300: this.computedAccuracy.n300 - (this.totalHits - ncircles) }));
         // Lots of arbitrary values from testing.
         // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
-        let accuracyValue = Math.pow(1.52163, this.difficultyAttributes.overallDifficulty) *
+        let accuracyValue = Math.pow(1.52163, this.overallDifficulty) *
             // It is possible to reach a negative accuracy with this formula. Cap it at zero - zero points.
             Math.pow(realAccuracy.n300 < 0 ? 0 : realAccuracy.value(), 24) *
             2.83;
@@ -3845,8 +3854,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             // Decrease bonus for AR > 10.
             accuracyValue *=
                 1 +
-                    0.08 *
-                        osuBase.Interpolation.reverseLerp(this.difficultyAttributes.approachRate, 11.5, 10);
+                    0.08 * osuBase.Interpolation.reverseLerp(this.approachRate, 11.5, 10);
         }
         if (this.mods.has(osuBase.ModFlashlight)) {
             accuracyValue *= 1.02;
@@ -3931,14 +3939,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         if (relevantCountGreat + relevantCountOk + relevantCountMeh <= 0) {
             return Number.POSITIVE_INFINITY;
         }
-        // Obtain the great, ok, and meh windows.
-        const { clockRate, overallDifficulty } = this.difficultyAttributes;
-        const hitWindow = new osuBase.OsuHitWindow(osuBase.OsuHitWindow.greatWindowToOD(
-        // Convert current OD to non clock rate-adjusted OD.
-        new osuBase.OsuHitWindow(overallDifficulty).greatWindow * clockRate));
-        const greatWindow = hitWindow.greatWindow / clockRate;
-        const okWindow = hitWindow.okWindow / clockRate;
-        const mehWindow = hitWindow.mehWindow / clockRate;
+        const { greatWindow, okWindow, mehWindow } = this;
         // The sample proportion of successful hits.
         const n = Math.max(1, relevantCountGreat + relevantCountOk);
         const p = relevantCountGreat / n;
@@ -4334,7 +4335,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
     }
     static calculateRateAdjustedOverallDifficulty(overallDifficulty, clockRate) {
         const greatWindow = new osuBase.OsuHitWindow(overallDifficulty).greatWindow / clockRate;
-        return osuBase.OsuHitWindow.greatWindowToOD(greatWindow);
+        return (79.5 - greatWindow) / 6;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.86",
+    "version": "4.0.0-beta.88",
     "description": "A module for calculating osu!standard beatmap difficulty and performance value with respect to the current difficulty and performance algorithm.",
     "keywords": [
         "osu",
@@ -33,10 +33,10 @@
         "url": "https://github.com/Rian8337/osu-droid-module/issues"
     },
     "dependencies": {
-        "@rian8337/osu-base": "4.0.0-beta.86"
+        "@rian8337/osu-base": "4.0.0-beta.88"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "62e3d012a8d3532fdb4410f6b48badda689b3a06"
+    "gitHead": "42c9324c999ed6dfe0804fe74131b870a72dd822"
 }

package/typings/index.d.ts

@@ -43,7 +43,7 @@ interface IDifficultyAttributes {
      */
     clockRate: number;
     /**
-     * The perceived overall difficulty inclusive of rate-adjusting mods (DT/HT/etc), based on osu!standard judgement.
+     * The perceived overall difficulty **exclusive** of rate-adjusting mods (DT/HT/etc).
      *
      * Rate-adjusting mods don't directly affect the overall difficulty value, but have a perceived effect as a result of adjusting audio timing.
      */
@@ -1143,7 +1143,7 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator<IDroidDif
      * [Graph](https://www.desmos.com/calculator/z5l9ebrwpi)
      */
     private calculateTapHighDeviationNerf;
-    private getConvertedHitWindow;
+    private getHitWindow;
     toString(): string;
 }
 
@@ -1316,7 +1316,7 @@ declare abstract class DroidTapEvaluator {
  */
 interface IOsuDifficultyAttributes extends IDifficultyAttributes {
     /**
-     * The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
+     * The perceived approach rate **exclusive** of rate-adjusting mods (DT/HT/etc).
      *
      * Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
      */
@@ -1531,6 +1531,11 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficu
      */
     get effectiveMissCount(): number;
     static readonly finalMultiplier = 1.14;
+    private greatWindow;
+    private okWindow;
+    private mehWindow;
+    private approachRate;
+    private overallDifficulty;
     private _effectiveMissCount;
     private speedDeviation;
     protected calculateValues(): void;