@rian8337/osu-difficulty-calculator 4.0.0-beta.82 → 4.0.0-beta.83

package/dist/index.js

@@ -326,7 +326,6 @@ class DifficultyHitObject {
     }
     setDistances(clockRate) {
         if (this.object instanceof osuBase.Slider) {
-            this.calculateSliderCursorPosition();
             this.travelDistance = this.lazyTravelDistance;
             // Bonus for repeat sliders until a better per nested object strain system can be achieved.
             if (this.mode === osuBase.Modes.droid) {
@@ -343,7 +342,7 @@ class DifficultyHitObject {
             this.lastObject instanceof osuBase.Spinner) {
             return;
         }
-        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
+        // We will scale distances by this factor, so we can assume a uniform circle size among beatmaps.
         let scalingFactor = DifficultyHitObject.normalizedRadius / this.object.radius;
         // High circle size (small CS) bonus
         if (this.mode === osuBase.Modes.osu && this.object.radius < 30) {
@@ -2193,7 +2192,11 @@ class PerformanceCalculator {
          */
         this.computedAccuracy = new osuBase.Accuracy({});
         /**
-         * The amount of misses that are filtered out from sliderbreaks.
+         * The calculated maximum combo.
+         */
+        this.combo = 0;
+        /**
+         * The amount of misses, including slider nested misses.
          */
         this.effectiveMissCount = 0;
         /**
@@ -2287,7 +2290,7 @@ class PerformanceCalculator {
         }
         const maxCombo = this.difficultyAttributes.maxCombo;
         const miss = this.computedAccuracy.nmiss;
-        let combo = (_b = options === null || options === void 0 ? void 0 : options.combo) !== null && _b !== void 0 ? _b : maxCombo - miss;
+        this.combo = (_b = options === null || options === void 0 ? void 0 : options.combo) !== null && _b !== void 0 ? _b : maxCombo - miss;
         if ((options === null || options === void 0 ? void 0 : options.sliderEndsDropped) !== undefined &&
             (options === null || options === void 0 ? void 0 : options.sliderTicksMissed) !== undefined) {
             this._usingClassicSliderAccuracy = false;
@@ -2300,8 +2303,8 @@ class PerformanceCalculator {
             this.sliderTicksMissed = 0;
         }
         // Ensure that combo is within possible bounds.
-        combo = osuBase.MathUtils.clamp(combo, 0, maxCombo - miss - this.sliderEndsDropped - this.sliderTicksMissed);
-        this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo);
+        this.combo = osuBase.MathUtils.clamp(this.combo, 0, maxCombo - miss - this.sliderEndsDropped - this.sliderTicksMissed);
+        this.effectiveMissCount = this.calculateEffectiveMissCount(maxCombo);
         if (this.mods.has(osuBase.ModNoFail)) {
             this.finalMultiplier *= Math.max(0.9, 1 - 0.02 * this.effectiveMissCount);
         }
@@ -2311,18 +2314,20 @@ class PerformanceCalculator {
                     Math.pow(this.difficultyAttributes.spinnerCount / this.totalHits, 0.85);
         }
         if (this.mods.has(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.difficultyAttributes.overallDifficulty > 0
-                ? 1 -
-                    Math.pow(this.difficultyAttributes.overallDifficulty /
-                        13.33, 1.8)
-                : 1);
-            const n50Multiplier = Math.max(0, this.difficultyAttributes.overallDifficulty > 0
-                ? 1 -
-                    Math.pow(this.difficultyAttributes.overallDifficulty /
-                        13.33, 5)
-                : 1);
+            const { overallDifficulty: od } = this.difficultyAttributes;
+            let n100Multiplier;
+            if (this.mode === osuBase.Modes.droid) {
+                // 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.
+                n100Multiplier =
+                    0.75 * Math.max(0, od > 0 ? 1 - od / 13.33 : 1);
+            }
+            else {
+                // 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.
+                n100Multiplier = Math.max(0, od > 0 ? 1 - Math.pow(od / 13.33, 1.8) : 1);
+            }
+            const n50Multiplier = Math.max(0, od > 0 ? 1 - Math.pow(od / 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 +
@@ -2335,7 +2340,7 @@ class PerformanceCalculator {
             if (this.usingClassicSliderAccuracy) {
                 // When the score is considered classic (regardless if it was made on old client or not),
                 // we consider all missing combo to be dropped difficult sliders.
-                estimateImproperlyFollowedDifficultSliders = osuBase.MathUtils.clamp(Math.min(this.totalImperfectHits, maxCombo - combo), 0, aimDifficultSliderCount);
+                estimateImproperlyFollowedDifficultSliders = osuBase.MathUtils.clamp(Math.min(this.totalImperfectHits, maxCombo - this.combo), 0, aimDifficultSliderCount);
             }
             else {
                 // We add tick misses here since they too mean that the player didn't follow the slider
@@ -2370,26 +2375,25 @@ class PerformanceCalculator {
     /**
      * Calculates the amount of misses + sliderbreaks from combo.
      */
-    calculateEffectiveMissCount(combo, maxCombo) {
+    calculateEffectiveMissCount(maxCombo) {
         let missCount = this.computedAccuracy.nmiss;
-        const { sliderCount } = this.difficultyAttributes;
-        if (sliderCount > 0) {
-            if (this.usingClassicSliderAccuracy || this.mode === osuBase.Modes.droid) {
+        if (this.difficultyAttributes.sliderCount > 0) {
+            if (this.usingClassicSliderAccuracy) {
                 // Consider that full combo is maximum combo minus dropped slider tails since
                 // they don't contribute to combo but also don't break it.
                 // In classic scores, we can't know the amount of dropped sliders so we estimate
                 // to 10% of all sliders in the beatmap.
-                const fullComboThreshold = maxCombo - 0.1 * sliderCount;
-                if (combo < fullComboThreshold) {
-                    missCount = fullComboThreshold / Math.max(1, combo);
+                const fullComboThreshold = maxCombo - 0.1 * this.difficultyAttributes.sliderCount;
+                if (this.combo < fullComboThreshold) {
+                    missCount = fullComboThreshold / Math.max(1, this.combo);
                 }
                 // In classic scores, there can't be more misses than a sum of all non-perfect judgements.
                 missCount = Math.min(missCount, this.totalImperfectHits);
             }
             else {
                 const fullComboThreshold = maxCombo - this.sliderEndsDropped;
-                if (combo < fullComboThreshold) {
-                    missCount = fullComboThreshold / Math.max(1, combo);
+                if (this.combo < fullComboThreshold) {
+                    missCount = fullComboThreshold / Math.max(1, this.combo);
                 }
                 // Combine regular misses with tick misses, since tick misses break combo as well.
                 missCount = Math.min(missCount, this.sliderTicksMissed + this.computedAccuracy.nmiss);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.82",
+    "version": "4.0.0-beta.83",
     "description": "A module for calculating osu!standard beatmap difficulty and performance value with respect to the current difficulty and performance algorithm.",
     "keywords": [
         "osu",
@@ -38,5 +38,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "de134bf082f310d8b84bfa2d99f42d1f2044398b"
+    "gitHead": "da2dd374cbbd45f8956f09a1248809318ac7025a"
 }

package/typings/index.d.ts

@@ -941,6 +941,10 @@ declare abstract class PerformanceCalculator<T extends IDifficultyAttributes> {
      * The calculated accuracy.
      */
     computedAccuracy: Accuracy;
+    /**
+     * The calculated maximum combo.
+     */
+    combo: number;
     /**
      * The difficulty attributes that is being calculated.
      */
@@ -960,7 +964,7 @@ declare abstract class PerformanceCalculator<T extends IDifficultyAttributes> {
      */
     protected abstract readonly mode: Modes;
     /**
-     * The amount of misses that are filtered out from sliderbreaks.
+     * The amount of misses, including slider nested misses.
      */
     protected effectiveMissCount: number;
     /**