@rian8337/osu-difficulty-calculator 4.0.0-beta.73 → 4.0.0-beta.75

package/dist/index.js

@@ -2064,6 +2064,12 @@ DroidDifficultyCalculator.threeFingerStrainThreshold = 175;
  * The base class of performance calculators.
  */
 class PerformanceCalculator {
+    /**
+     * Whether this score uses classic slider accuracy.
+     */
+    get usingClassicSliderAccuracy() {
+        return this._usingClassicSliderAccuracy;
+    }
     /**
      * @param difficultyAttributes The difficulty attributes to calculate.
      */
@@ -2080,6 +2086,17 @@ class PerformanceCalculator {
          * The amount of misses that are filtered out from sliderbreaks.
          */
         this.effectiveMissCount = 0;
+        /**
+         * The amount of slider ends dropped in the score.
+         */
+        this.sliderEndsDropped = 0;
+        /**
+         * The amount of slider ticks missed in the score.
+         *
+         * This is used to calculate the slider accuracy.
+         */
+        this.sliderTicksMissed = 0;
+        this._usingClassicSliderAccuracy = false;
         /**
          * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
          */
@@ -2160,7 +2177,20 @@ class PerformanceCalculator {
         }
         const maxCombo = this.difficultyAttributes.maxCombo;
         const miss = this.computedAccuracy.nmiss;
-        const combo = (_b = options === null || options === void 0 ? void 0 : options.combo) !== null && _b !== void 0 ? _b : maxCombo - miss;
+        let 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;
+            this.sliderEndsDropped = options.sliderEndsDropped;
+            this.sliderTicksMissed = options.sliderTicksMissed;
+        }
+        else {
+            this._usingClassicSliderAccuracy = true;
+            this.sliderEndsDropped = 0;
+            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);
         if (this.mods.has(osuBase.ModNoFail)) {
             this.finalMultiplier *= Math.max(0.9, 1 - 0.02 * this.effectiveMissCount);
@@ -2189,18 +2219,43 @@ class PerformanceCalculator {
                 this.computedAccuracy.n100 * n100Multiplier +
                 this.computedAccuracy.n50 * n50Multiplier, this.totalHits);
         }
-        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.difficultyAttributes.sliderCount * 0.15;
-            const estimateSliderEndsDropped = osuBase.MathUtils.clamp(Math.min(this.computedAccuracy.n100 +
-                this.computedAccuracy.n50 +
-                this.computedAccuracy.nmiss, maxCombo - combo), 0, estimateDifficultSliders);
-            this.sliderNerfFactor =
-                (1 - this.difficultyAttributes.sliderFactor) *
-                    Math.pow(1 -
-                        estimateSliderEndsDropped /
-                            estimateDifficultSliders, 3) +
-                    this.difficultyAttributes.sliderFactor;
+        const { sliderCount, sliderFactor, aimDifficultSliderCount } = this.difficultyAttributes;
+        if (sliderCount > 0) {
+            if (this.mode === osuBase.Modes.droid) {
+                // We assume 15% of sliders in a beatmap are difficult since there's no way to tell from the performance calculator.
+                const estimateDifficultSliders = sliderCount * 0.15;
+                const estimateSliderEndsDropped = osuBase.MathUtils.clamp(Math.min(this.computedAccuracy.n100 +
+                    this.computedAccuracy.n50 +
+                    this.computedAccuracy.nmiss, maxCombo - combo), 0, estimateDifficultSliders);
+                this.sliderNerfFactor =
+                    (1 - sliderFactor) *
+                        Math.pow(1 -
+                            estimateSliderEndsDropped /
+                                estimateDifficultSliders, 3) +
+                        sliderFactor;
+            }
+            else {
+                let estimateImproperlyFollowedDifficultSliders;
+                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);
+                }
+                else {
+                    // We add tick misses here since they too mean that the player didn't follow the slider
+                    // properly. However aren't adding misses here because missing slider heads has a harsh
+                    // penalty by itself and doesn't mean that the rest of the slider wasn't followed properly.
+                    estimateImproperlyFollowedDifficultSliders =
+                        osuBase.MathUtils.clamp(this.sliderEndsDropped + this.sliderTicksMissed, 0, aimDifficultSliderCount);
+                }
+                this.sliderNerfFactor =
+                    (1 - sliderFactor) *
+                        Math.pow(1 -
+                            estimateImproperlyFollowedDifficultSliders /
+                                aimDifficultSliderCount, 3) +
+                        sliderFactor;
+            }
         }
     }
     /**
@@ -2223,18 +2278,31 @@ class PerformanceCalculator {
      * Calculates the amount of misses + sliderbreaks from combo.
      */
     calculateEffectiveMissCount(combo, maxCombo) {
-        // Guess the number of misses + slider breaks from combo.
-        let comboBasedMissCount = 0;
-        if (this.difficultyAttributes.sliderCount > 0) {
-            const fullComboThreshold = maxCombo - 0.1 * this.difficultyAttributes.sliderCount;
-            if (combo < fullComboThreshold) {
-                // Clamp miss count to maximum amount of possible breaks.
-                comboBasedMissCount = Math.min(fullComboThreshold / Math.max(1, combo), this.computedAccuracy.n100 +
-                    this.computedAccuracy.n50 +
-                    this.computedAccuracy.nmiss);
+        let missCount = this.computedAccuracy.nmiss;
+        const { sliderCount } = this.difficultyAttributes;
+        if (sliderCount > 0) {
+            if (this.usingClassicSliderAccuracy || this.mode === osuBase.Modes.droid) {
+                // 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);
+                }
+                // 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);
+                }
+                // Combine regular misses with tick misses, since tick misses break combo as well.
+                missCount = Math.min(missCount, this.sliderTicksMissed + this.computedAccuracy.nmiss);
             }
         }
-        return Math.max(this.computedAccuracy.nmiss, comboBasedMissCount);
+        return osuBase.MathUtils.clamp(missCount, this.computedAccuracy.nmiss, this.totalHits);
     }
     /**
      * Determines whether an attribute is a cacheable attribute.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.73",
+    "version": "4.0.0-beta.75",
     "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.73"
+        "@rian8337/osu-base": "^4.0.0-beta.74"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "e68f26caa3ddc53bbbfa3ab59a6773d0f445e136"
+    "gitHead": "1e8a43d98546e5071bebe45b3ca40dd496aa7b21"
 }

package/typings/index.d.ts

@@ -983,6 +983,21 @@ declare abstract class PerformanceCalculator<T extends IDifficultyAttributes> {
      * The amount of misses that are filtered out from sliderbreaks.
      */
     protected effectiveMissCount: number;
+    /**
+     * The amount of slider ends dropped in the score.
+     */
+    protected sliderEndsDropped: number;
+    /**
+     * The amount of slider ticks missed in the score.
+     *
+     * This is used to calculate the slider accuracy.
+     */
+    protected sliderTicksMissed: number;
+    private _usingClassicSliderAccuracy;
+    /**
+     * Whether this score uses classic slider accuracy.
+     */
+    protected get usingClassicSliderAccuracy(): boolean;
     /**
      * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
      */