@rian8337/osu-difficulty-calculator 4.0.0-beta.74 → 4.0.0-beta.76

package/dist/index.js

@@ -849,15 +849,18 @@ class DroidAimEvaluator {
      * Calculates the flow aim strain of a hitobject.
      */
     static flowAimStrainOf(current) {
-        var _a, _b;
+        var _a;
         let speedBonus = 1;
         if (current.strainTime < this.minSpeedBonus) {
             speedBonus +=
                 0.75 *
                     Math.pow((this.minSpeedBonus - current.strainTime) / 40, 2);
         }
-        const travelDistance = (_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.travelDistance) !== null && _b !== void 0 ? _b : 0;
-        const shortDistancePenalty = Math.pow(Math.min(this.singleSpacingThreshold, travelDistance + current.minimumJumpDistance) / this.singleSpacingThreshold, 3.5);
+        const prev = current.previous(0);
+        // Punish low spacing as it is easier to aim.
+        const travelDistance = (_a = prev === null || prev === void 0 ? void 0 : prev.travelDistance) !== null && _a !== void 0 ? _a : 0;
+        const distance = travelDistance + current.minimumJumpDistance;
+        const shortDistancePenalty = Math.min(1, Math.pow(distance / this.singleSpacingThreshold, 3.5));
         return (200 * speedBonus * shortDistancePenalty) / current.strainTime;
     }
     static calculateWideAngleBonus(angle) {
@@ -872,7 +875,7 @@ DroidAimEvaluator.acuteAngleMultiplier = 2.6;
 DroidAimEvaluator.sliderMultiplier = 1.35;
 DroidAimEvaluator.velocityChangeMultiplier = 0.75;
 DroidAimEvaluator.wiggleMultiplier = 1.02;
-DroidAimEvaluator.singleSpacingThreshold = 100;
+DroidAimEvaluator.singleSpacingThreshold = DroidDifficultyHitObject.normalizedDiameter;
 // 200 1/4 BPM delta time
 DroidAimEvaluator.minSpeedBonus = 75;
 
@@ -1028,7 +1031,7 @@ class DroidAim extends DroidSkill {
         this.reducedSectionCount = 10;
         this.reducedSectionBaseline = 0.75;
         this.starsPerDouble = 1.05;
-        this.skillMultiplier = 25.6;
+        this.skillMultiplier = 26.5;
         this.currentAimStrain = 0;
         this.sliderStrains = [];
         this.withSliders = withSliders;
@@ -1230,7 +1233,7 @@ class DroidFlashlight extends DroidSkill {
         this.reducedSectionCount = 0;
         this.reducedSectionBaseline = 1;
         this.starsPerDouble = 1.06;
-        this.skillMultiplier = 0.02;
+        this.skillMultiplier = 0.023;
         this.currentFlashlightStrain = 0;
         this.withSliders = withSliders;
     }
@@ -1501,7 +1504,6 @@ class DroidTapEvaluator {
      * - 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.
      */
@@ -1511,7 +1513,6 @@ class DroidTapEvaluator {
             current.isOverlapping(false)) {
             return 0;
         }
-        // Nerf doubletappable doubles.
         const doubletapness = considerCheesability
             ? 1 - current.doubletapness
             : 1;
@@ -1646,7 +1647,7 @@ class DroidVisualEvaluator {
             current.index === 0) {
             return 0;
         }
-        // Start with base density and give global bonus for Hidden and Traceable.
+        // Start with base density and give global bonus for Hidden.
         // Add density caps for sanity.
         let strain;
         if (mods.has(osuBase.ModHidden)) {
@@ -1737,7 +1738,7 @@ class DroidVisual extends DroidSkill {
         this.strainDecayBase = 0.1;
         this.currentVisualStrain = 0;
         this.currentRhythmMultiplier = 1;
-        this.skillMultiplier = 10;
+        this.skillMultiplier = 11.2;
         this.withSliders = withSliders;
     }
     strainValueAt(current) {
@@ -2064,6 +2065,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 +2087,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 +2178,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 +2220,26 @@ 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);
+        const { aimDifficultSliderCount, sliderFactor } = this.difficultyAttributes;
+        if (aimDifficultSliderCount > 0) {
+            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 - this.difficultyAttributes.sliderFactor) *
+                (1 - sliderFactor) *
                     Math.pow(1 -
-                        estimateSliderEndsDropped /
-                            estimateDifficultSliders, 3) +
-                    this.difficultyAttributes.sliderFactor;
+                        estimateImproperlyFollowedDifficultSliders /
+                            aimDifficultSliderCount, 3) +
+                    sliderFactor;
         }
     }
     /**
@@ -2223,18 +2262,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.
@@ -2424,7 +2476,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             Math.pow(this.visual, 1.1), 1 / 1.1) * this.finalMultiplier);
     }
     handleOptions(options) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         this._tapPenalty = (_a = options === null || options === void 0 ? void 0 : options.tapPenalty) !== null && _a !== void 0 ? _a : 1;
         this._aimSliderCheesePenalty = (_b = options === null || options === void 0 ? void 0 : options.aimSliderCheesePenalty) !== null && _b !== void 0 ? _b : 1;
         this._flashlightSliderCheesePenalty =
@@ -2432,18 +2484,6 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         this._visualSliderCheesePenalty =
             (_d = options === null || options === void 0 ? void 0 : options.visualSliderCheesePenalty) !== null && _d !== void 0 ? _d : 1;
         super.handleOptions(options);
-        const { maxCombo, aimDifficultSliderCount, sliderFactor } = this.difficultyAttributes;
-        const combo = (_e = options === null || options === void 0 ? void 0 : options.combo) !== null && _e !== void 0 ? _e : maxCombo - this.computedAccuracy.nmiss;
-        if (aimDifficultSliderCount > 0) {
-            // Consider all missing combo to be dropped difficult sliders.
-            const estimateImproperlyFollowedDifficultSliders = osuBase.MathUtils.clamp(Math.min(this.totalImperfectHits, maxCombo - combo), 0, aimDifficultSliderCount);
-            this.sliderNerfFactor =
-                (1 - sliderFactor) *
-                    Math.pow(1 -
-                        estimateImproperlyFollowedDifficultSliders /
-                            aimDifficultSliderCount, 3) +
-                    sliderFactor;
-        }
     }
     /**
      * Calculates the aim performance value of the beatmap.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.74",
+    "version": "4.0.0-beta.76",
     "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": "00abc82040e820ccff8fcad7ee77d7e7d8031717"
+    "gitHead": "d843f2cf65e2e44c87654a2be675d6ed925193ea"
 }

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.
      */
@@ -1298,7 +1313,6 @@ declare abstract class DroidTapEvaluator {
      * - 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.
      */