@rian8337/osu-difficulty-calculator 4.0.0-beta.30 → 4.0.0-beta.32

package/dist/index.js

@@ -664,11 +664,19 @@ class StrainSkill extends Skill {
          * Strain peaks are stored here.
          */
         this.strainPeaks = [];
+        this._objectStrains = [];
+        this.difficulty = 0;
         this.sectionLength = 400;
         this.currentStrain = 0;
         this.currentSectionPeak = 0;
         this.currentSectionEnd = 0;
     }
+    /**
+     * The strains of hitobjects.
+     */
+    get objectStrains() {
+        return this._objectStrains;
+    }
     process(current) {
         // The first object doesn't generate a strain, so we begin with an incremented section end
         if (current.index === 0) {
@@ -694,6 +702,21 @@ class StrainSkill extends Skill {
     saveCurrentPeak() {
         this.strainPeaks.push(this.currentSectionPeak);
     }
+    /**
+     * Returns the number of strains weighed against the top strain.
+     *
+     * The result is scaled by clock rate as it affects the total number of strains.
+     */
+    countDifficultStrains() {
+        if (this.difficulty === 0) {
+            return 0;
+        }
+        // This is what the top strain is if all strain values were identical.
+        const consistentTopStrain = this.difficulty / 10;
+        // Use a weighted sum of all strains.
+        return this._objectStrains.reduce((total, next) => total +
+            1.1 / (1 + Math.exp(-10 * (next / consistentTopStrain - 0.88))), 0);
+    }
     /**
      * Calculates strain decay for a specified time frame.
      *
@@ -730,32 +753,6 @@ class StrainSkill extends Skill {
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
  */
 class DroidSkill extends StrainSkill {
-    constructor() {
-        super(...arguments);
-        this._objectStrains = [];
-        this.difficulty = 0;
-    }
-    /**
-     * The strains of hitobjects.
-     */
-    get objectStrains() {
-        return this._objectStrains;
-    }
-    /**
-     * Returns the number of strains weighed against the top strain.
-     *
-     * The result is scaled by clock rate as it affects the total number of strains.
-     */
-    countDifficultStrains() {
-        if (this.difficulty === 0) {
-            return 0;
-        }
-        // This is what the top strain is if all strain values were identical.
-        const consistentTopStrain = this.difficulty / 10;
-        // Use a weighted sum of all strains.
-        return this._objectStrains.reduce((total, next) => total +
-            1.1 / (1 + Math.exp(-10 * (next / consistentTopStrain - 0.88))), 0);
-    }
     process(current) {
         super.process(current);
         this._objectStrains.push(this.getObjectStrain(current));
@@ -1137,6 +1134,7 @@ class Island {
             this.deltaCount === other.deltaCount);
     }
 }
+
 /**
  * An evaluator for calculating osu!droid Rhythm skill.
  */
@@ -2086,10 +2084,6 @@ class PerformanceCalculator {
          * The calculated accuracy.
          */
         this.computedAccuracy = new osuBase.Accuracy({});
-        /**
-         * Penalty for combo breaks.
-         */
-        this.comboPenalty = 0;
         /**
          * The amount of misses that are filtered out from sliderbreaks.
          */
@@ -2149,7 +2143,6 @@ class PerformanceCalculator {
         const maxCombo = this.difficultyAttributes.maxCombo;
         const miss = this.computedAccuracy.nmiss;
         const combo = (_a = options === null || options === void 0 ? void 0 : options.combo) !== null && _a !== void 0 ? _a : maxCombo - miss;
-        this.comboPenalty = Math.min(Math.pow(combo / maxCombo, 0.8), 1);
         if ((options === null || options === void 0 ? void 0 : options.accPercent) instanceof osuBase.Accuracy) {
             // Copy into new instance to not modify the original
             this.computedAccuracy = new osuBase.Accuracy(options.accPercent);
@@ -2187,7 +2180,7 @@ class PerformanceCalculator {
                     Math.pow(this.difficultyAttributes.overallDifficulty /
                         13.33, 1.8)
                 : 1);
-            const n50Multiplier = Math.max(0, this.difficultyAttributes.overallDifficulty > 0.0
+            const n50Multiplier = Math.max(0, this.difficultyAttributes.overallDifficulty > 0
                 ? 1 -
                     Math.pow(this.difficultyAttributes.overallDifficulty /
                         13.33, 5)
@@ -2212,6 +2205,22 @@ class PerformanceCalculator {
                     this.difficultyAttributes.sliderFactor;
         }
     }
+    /**
+     * Calculates a strain-based miss penalty.
+     *
+     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    calculateStrainBasedMissPenalty(difficultStrainCount) {
+        if (this.effectiveMissCount === 0) {
+            return 1;
+        }
+        return (0.96 /
+            (this.effectiveMissCount /
+                (4 * Math.pow(Math.log(difficultStrainCount), 0.94)) +
+                1));
+    }
     /**
      * Calculates the amount of misses + sliderbreaks from combo.
      */
@@ -2555,22 +2564,6 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         visualValue *= 0.98 + Math.pow(5, 2) / 2500;
         return visualValue;
     }
-    /**
-     * Calculates a strain-based miss penalty.
-     *
-     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
-     * so we use the amount of relatively difficult sections to adjust miss penalty
-     * to make it more punishing on maps with lower amount of hard sections.
-     */
-    calculateStrainBasedMissPenalty(difficultStrainCount) {
-        if (this.effectiveMissCount === 0) {
-            return 1;
-        }
-        return (0.96 /
-            (this.effectiveMissCount /
-                (4 * Math.pow(Math.log(difficultStrainCount), 0.94)) +
-                1));
-    }
     /**
      * The object-based proportional miss penalty.
      */
@@ -2781,17 +2774,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
  */
 class OsuSkill extends StrainSkill {
-    constructor() {
-        super(...arguments);
-        /**
-         * The final multiplier to be applied to the final difficulty value after all other calculations.
-         */
-        this.difficultyMultiplier = OsuSkill.defaultDifficultyMultiplier;
-    }
     difficultyValue() {
-        const strains = this.strainPeaks
-            .slice()
-            .sort((a, b) => b - a);
+        const strains = this.strainPeaks.slice().sort((a, b) => b - a);
         if (this.reducedSectionCount > 0) {
             // We are reducing the highest strains first to account for extreme difficulty spikes.
             for (let i = 0; i < Math.min(strains.length, this.reducedSectionCount); ++i) {
@@ -2802,25 +2786,19 @@ class OsuSkill extends StrainSkill {
         }
         // Difficulty is the weighted sum of the highest strains from every section.
         // We're sorting from highest to lowest strain.
-        let difficulty = 0;
+        this.difficulty = 0;
         let weight = 1;
         for (const strain of strains) {
             const addition = strain * weight;
-            if (difficulty + addition === difficulty) {
+            if (this.difficulty + addition === this.difficulty) {
                 break;
             }
-            difficulty += addition;
+            this.difficulty += addition;
             weight *= this.decayWeight;
         }
-        return difficulty * this.difficultyMultiplier;
+        return this.difficulty;
     }
 }
-/**
- * The default multiplier applied to the final difficulty value after all other calculations.
- *
- * May be overridden via {@link difficultyMultiplier}.
- */
-OsuSkill.defaultDifficultyMultiplier = 1.06;
 
 /**
  * An evaluator for calculating osu!standard Aim skill.
@@ -2955,7 +2933,7 @@ class OsuAim extends OsuSkill {
         this.reducedSectionBaseline = 0.75;
         this.decayWeight = 0.9;
         this.currentAimStrain = 0;
-        this.skillMultiplier = 23.55;
+        this.skillMultiplier = 25.18;
         this.withSliders = withSliders;
     }
     strainValueAt(current) {
@@ -2963,6 +2941,7 @@ class OsuAim extends OsuSkill {
         this.currentAimStrain +=
             OsuAimEvaluator.evaluateDifficultyOf(current, this.withSliders) *
                 this.skillMultiplier;
+        this._objectStrains.push(this.currentAimStrain);
         return this.currentAimStrain;
     }
     calculateInitialStrain(time, current) {
@@ -3008,24 +2987,32 @@ class OsuSpeedEvaluator extends SpeedEvaluator {
         // Cap deltatime to the OD 300 hitwindow.
         // 0.93 is derived from making sure 260 BPM 1/4 OD8 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.
         strainTime /= osuBase.MathUtils.clamp(strainTime / current.fullGreatWindow / 0.93, 0.92, 1);
-        let speedBonus = 1;
+        // speedBonus will be 0.0 for BPM < 200
+        let speedBonus = 0;
+        // Add additional scaling bonus for streams/bursts higher than 200bpm
         if (strainTime < this.minSpeedBonus) {
-            speedBonus +=
+            speedBonus =
                 0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
         }
         const travelDistance = (_a = prev === null || prev === void 0 ? void 0 : prev.travelDistance) !== null && _a !== void 0 ? _a : 0;
+        // Cap distance at spacing threshold
         const distance = Math.min(this.SINGLE_SPACING_THRESHOLD, travelDistance + current.minimumJumpDistance);
-        return (((speedBonus +
-            speedBonus *
-                Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 3.5)) *
-            doubletapness) /
-            strainTime);
+        // Max distance bonus is 1 * `distance_multiplier` at single_spacing_threshold
+        const distanceBonus = Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 3.95) *
+            this.DISTANCE_MULTIPLIER;
+        // Base difficulty with all bonuses
+        const difficulty = ((1 + speedBonus + distanceBonus) * 1000) / strainTime;
+        // Apply penalty if there's doubletappable doubles
+        return difficulty * doubletapness;
     }
 }
 /**
  * Spacing threshold for a single hitobject spacing.
+ *
+ * About 1.25 circles distance between hitobject centers.
  */
 OsuSpeedEvaluator.SINGLE_SPACING_THRESHOLD = 125;
+OsuSpeedEvaluator.DISTANCE_MULTIPLIER = 0.94;
 
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
@@ -3036,20 +3023,21 @@ class OsuRhythmEvaluator {
      * with historic data of the current object.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      */
     static evaluateDifficultyOf(current) {
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
-        let previousIslandSize = 0;
+        const deltaDifferenceEpsilon = current.fullGreatWindow * 0.3;
         let rhythmComplexitySum = 0;
-        let islandSize = 1;
+        let island = new Island(deltaDifferenceEpsilon);
+        let previousIsland = new Island(deltaDifferenceEpsilon);
+        const islandCounts = new Map();
         // Store the ratio of the current start of an island to buff for tighter rhythms.
         let startRatio = 0;
         let firstDeltaSwitch = false;
-        const historicalNoteCount = Math.min(current.index, 32);
         let rhythmStart = 0;
+        const historicalNoteCount = Math.min(current.index, this.historyObjectsMax);
         while (rhythmStart < historicalNoteCount - 2 &&
             current.startTime - current.previous(rhythmStart).startTime <
                 this.historyTimeMax) {
@@ -3060,84 +3048,119 @@ class OsuRhythmEvaluator {
             const prevObject = current.previous(i);
             const lastObject = current.previous(i + 1);
             // Scale note 0 to 1 from history to now.
-            let currentHistoricalDecay = (this.historyTimeMax -
+            const timeDecay = (this.historyTimeMax -
                 (current.startTime - currentObject.startTime)) /
                 this.historyTimeMax;
+            const noteDecay = (historicalNoteCount - i) / historicalNoteCount;
             // Either we're limited by time or limited by object count.
-            currentHistoricalDecay = Math.min(currentHistoricalDecay, (historicalNoteCount - i) / historicalNoteCount);
+            const currentHistoricalDecay = Math.min(timeDecay, noteDecay);
             const currentDelta = currentObject.strainTime;
             const prevDelta = prevObject.strainTime;
             const lastDelta = lastObject.strainTime;
+            // Calculate how much current delta difference deserves a rhythm bonus
+            // This function is meant to reduce rhythm bonus for deltas that are multiples of each other (i.e. 100 and 200)
+            const deltaDifferenceRatio = Math.min(prevDelta, currentDelta) /
+                Math.max(prevDelta, currentDelta);
             const currentRatio = 1 +
-                6 *
-                    Math.min(0.5, Math.pow(Math.sin(Math.PI /
-                        (Math.min(prevDelta, currentDelta) /
-                            Math.max(prevDelta, currentDelta))), 2));
-            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) -
-                current.fullGreatWindow * 0.3) /
-                (current.fullGreatWindow * 0.3));
-            let effectiveRatio = windowPenalty * currentRatio;
+                this.rhythmRatioMultiplier *
+                    Math.min(0.5, Math.pow(Math.sin(Math.PI / deltaDifferenceRatio), 2));
+            // Reduce ratio bonus if delta difference is too big
+            const fraction = Math.max(prevDelta / currentDelta, currentDelta / prevDelta);
+            const fractionMultiplier = osuBase.MathUtils.clamp(2 - fraction / 8, 0, 1);
+            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - deltaDifferenceEpsilon) / deltaDifferenceEpsilon);
+            let effectiveRatio = windowPenalty * currentRatio * fractionMultiplier;
             if (firstDeltaSwitch) {
-                if (prevDelta <= 1.25 * currentDelta &&
-                    prevDelta * 1.25 >= currentDelta) {
+                if (Math.abs(prevDelta - currentDelta) < deltaDifferenceEpsilon) {
                     // Island is still progressing, count size.
-                    if (islandSize < 7) {
-                        ++islandSize;
-                    }
+                    island.addDelta(currentDelta);
                 }
                 else {
+                    // BPM change is into slider, this is easy acc window.
                     if (currentObject.object instanceof osuBase.Slider) {
-                        // BPM change is into slider, this is easy acc window.
                         effectiveRatio /= 8;
                     }
+                    // BPM change was from a slider, this is easier typically than circle -> circle.
+                    // Unintentional side effect is that bursts with kicksliders at the ends might have lower difficulty
+                    // than bursts without sliders.
                     if (prevObject.object instanceof osuBase.Slider) {
-                        // BPM change was from a slider, this is typically easier than circle -> circle.
-                        effectiveRatio /= 4;
-                    }
-                    if (previousIslandSize === islandSize) {
-                        // Repeated island size (ex: triplet -> triplet).
-                        effectiveRatio /= 4;
+                        effectiveRatio *= 0.3;
                     }
-                    if (previousIslandSize % 2 === islandSize % 2) {
-                        // Repeated island polarity (2 -> 4, 3 -> 5).
+                    // Repeated island polarity (2 -> 4, 3 -> 5).
+                    if (island.isSimilarPolarity(previousIsland)) {
                         effectiveRatio /= 2;
                     }
-                    if (lastDelta > prevDelta + 10 &&
-                        prevDelta > currentDelta + 10) {
-                        // Previous increase happened a note ago.
-                        // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                    // Previous increase happened a note ago.
+                    // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                    if (lastDelta > prevDelta + deltaDifferenceEpsilon &&
+                        prevDelta > currentDelta + deltaDifferenceEpsilon) {
                         effectiveRatio /= 8;
                     }
+                    // Repeated island size (ex: triplet -> triplet).
+                    // TODO: remove this nerf since its staying here only for balancing purposes because of the flawed ratio calculation
+                    if (previousIsland.deltaCount == island.deltaCount) {
+                        effectiveRatio /= 2;
+                    }
+                    let islandFound = false;
+                    for (const [currentIsland, count] of islandCounts) {
+                        if (!island.equals(currentIsland)) {
+                            continue;
+                        }
+                        islandFound = true;
+                        let islandCount = count;
+                        if (previousIsland.equals(island)) {
+                            // Only add island to island counts if they're going one after another.
+                            ++islandCount;
+                            islandCounts.set(currentIsland, islandCount);
+                        }
+                        // Repeated island (ex: triplet -> triplet).
+                        // Graph: https://www.desmos.com/calculator/pj7an56zwf
+                        effectiveRatio *= Math.min(3 / islandCount, Math.pow(1 / islandCount, 2.75 / (1 + Math.exp(14 - 0.24 * island.delta))));
+                        break;
+                    }
+                    if (!islandFound) {
+                        islandCounts.set(island, 1);
+                    }
+                    // Scale down the difficulty if the object is doubletappable.
+                    effectiveRatio *= 1 - prevObject.doubletapness * 0.75;
                     rhythmComplexitySum +=
-                        (((Math.sqrt(effectiveRatio * startRatio) *
-                            currentHistoricalDecay *
-                            Math.sqrt(4 + islandSize)) /
-                            2) *
-                            Math.sqrt(4 + previousIslandSize)) /
-                            2;
+                        Math.sqrt(effectiveRatio * startRatio) *
+                            currentHistoricalDecay;
                     startRatio = effectiveRatio;
-                    previousIslandSize = islandSize;
-                    if (prevDelta * 1.25 < currentDelta) {
+                    previousIsland = island;
+                    if (prevDelta + deltaDifferenceEpsilon < currentDelta) {
                         // We're slowing down, stop counting.
                         // If we're speeding up, this stays as is and we keep counting island size.
                         firstDeltaSwitch = false;
                     }
-                    islandSize = 1;
+                    island = new Island(currentDelta, deltaDifferenceEpsilon);
                 }
             }
-            else if (prevDelta > 1.25 * currentDelta) {
-                // We want to be speeding up.
+            else if (prevDelta > currentDelta + deltaDifferenceEpsilon) {
+                // We are speeding up.
                 // Begin counting island until we change speed again.
                 firstDeltaSwitch = true;
+                // BPM change is into slider, this is easy acc window.
+                if (currentObject.object instanceof osuBase.Slider) {
+                    effectiveRatio *= 0.6;
+                }
+                // BPM change was from a slider, this is easier typically than circle -> circle
+                // Unintentional side effect is that bursts with kicksliders at the ends might have lower difficulty
+                // than bursts without sliders
+                if (prevObject.object instanceof osuBase.Slider) {
+                    effectiveRatio *= 0.6;
+                }
                 startRatio = effectiveRatio;
-                islandSize = 1;
+                island = new Island(currentDelta, deltaDifferenceEpsilon);
             }
         }
-        return Math.sqrt(4 + rhythmComplexitySum * this.rhythmMultiplier) / 2;
+        return (Math.sqrt(4 + rhythmComplexitySum * this.rhythmOverallMultiplier) /
+            2);
     }
 }
-OsuRhythmEvaluator.rhythmMultiplier = 0.75;
 OsuRhythmEvaluator.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
+OsuRhythmEvaluator.historyObjectsMax = 32;
+OsuRhythmEvaluator.rhythmOverallMultiplier = 0.95;
+OsuRhythmEvaluator.rhythmRatioMultiplier = 12;
 
 /**
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
@@ -3148,11 +3171,10 @@ class OsuSpeed extends OsuSkill {
         this.strainDecayBase = 0.3;
         this.reducedSectionCount = 5;
         this.reducedSectionBaseline = 0.75;
-        this.difficultyMultiplier = 1.04;
         this.decayWeight = 0.9;
         this.currentSpeedStrain = 0;
         this.currentRhythm = 0;
-        this.skillMultiplier = 1375;
+        this.skillMultiplier = 1.43;
     }
     /**
      * @param current The hitobject to calculate.
@@ -3163,7 +3185,9 @@ class OsuSpeed extends OsuSkill {
             OsuSpeedEvaluator.evaluateDifficultyOf(current) *
                 this.skillMultiplier;
         this.currentRhythm = OsuRhythmEvaluator.evaluateDifficultyOf(current);
-        return this.currentSpeedStrain * this.currentRhythm;
+        const strain = this.currentSpeedStrain * this.currentRhythm;
+        this._objectStrains.push(strain);
+        return strain;
     }
     calculateInitialStrain(time, current) {
         var _a, _b;
@@ -3211,7 +3235,7 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
             if (!(currentObject.object instanceof osuBase.Spinner)) {
                 const jumpDistance = current.object
                     .getStackedPosition(osuBase.Modes.osu)
-                    .subtract(currentObject.object.endPosition).length;
+                    .subtract(currentObject.object.getStackedEndPosition(osuBase.Modes.osu)).length;
                 cumulativeStrainTime += last.strainTime;
                 // We want to nerf objects that can be easily seen within the Flashlight circle radius.
                 if (i === 0) {
@@ -3273,9 +3297,12 @@ class OsuFlashlight extends OsuSkill {
         this.reducedSectionBaseline = 1;
         this.decayWeight = 1;
         this.currentFlashlightStrain = 0;
-        this.skillMultiplier = 0.052;
+        this.skillMultiplier = 0.05512;
         this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
     }
+    difficultyValue() {
+        return this.strainPeaks.reduce((a, b) => a + b, 0);
+    }
     strainValueAt(current) {
         this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
         this.currentFlashlightStrain +=
@@ -3343,6 +3370,8 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             hitCircleCount: 0,
             sliderCount: 0,
             spinnerCount: 0,
+            aimDifficultStrainCount: 0,
+            speedDifficultStrainCount: 0,
         };
         this.difficultyMultiplier = 0.0675;
         this.mode = osuBase.Modes.osu;
@@ -3411,7 +3440,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             // Document for formula derivation:
             // https://docs.google.com/document/d/10DZGYYSsT_yjz2Mtp6yIJld0Rqx4E-vVHupCqiM4TNI/edit
             this.attributes.starRating =
-                Math.cbrt(1.14) *
+                Math.cbrt(1.15) *
                     0.027 *
                     (Math.cbrt((100000 / Math.pow(2, 1 / 1.1)) * basePerformanceValue) +
                         4);
@@ -3496,6 +3525,8 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.attributes.aimDifficulty *= 0.9;
         }
+        this.attributes.aimDifficultStrainCount =
+            aimSkill.countDifficultStrains();
     }
     /**
      * Called after speed skill calculation.
@@ -3505,6 +3536,8 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
     postCalculateSpeed(speedSkill) {
         this.strainPeaks.speed = speedSkill.strainPeaks;
         this.attributes.speedDifficulty = this.starValue(speedSkill.difficultyValue());
+        this.attributes.speedDifficultStrainCount =
+            speedSkill.countDifficultStrains();
     }
     /**
      * Calculates speed-related attributes.
@@ -3555,8 +3588,9 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
          * The flashlight performance value.
          */
         this.flashlight = 0;
-        this.finalMultiplier = 1.14;
+        this.finalMultiplier = 1.15;
         this.mode = osuBase.Modes.osu;
+        this.comboPenalty = 1;
     }
     calculateValues() {
         this.aim = this.calculateAimValue();
@@ -3570,6 +3604,14 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             Math.pow(this.accuracy, 1.1) +
             Math.pow(this.flashlight, 1.1), 1 / 1.1) * this.finalMultiplier);
     }
+    handleOptions(options) {
+        var _a;
+        super.handleOptions(options);
+        const maxCombo = this.difficultyAttributes.maxCombo;
+        const miss = this.computedAccuracy.nmiss;
+        const combo = (_a = options === null || options === void 0 ? void 0 : options.combo) !== null && _a !== void 0 ? _a : maxCombo - miss;
+        this.comboPenalty = Math.min(Math.pow(combo / maxCombo, 0.8), 1);
+    }
     /**
      * Calculates the aim performance value of the beatmap.
      */
@@ -3581,16 +3623,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             lengthBonus += Math.log10(this.totalHits / 2000) * 0.5;
         }
         aimValue *= 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.
-            aimValue *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
-        }
-        // Combo scaling
-        aimValue *= this.comboPenalty;
+        aimValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.aimDifficultStrainCount);
         const calculatedAR = this.difficultyAttributes.approachRate;
         if (!this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
             // AR scaling
@@ -3631,16 +3664,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             lengthBonus += Math.log10(this.totalHits / 2000) * 0.5;
         }
         speedValue *= 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.
-            speedValue *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
-        }
-        // Combo scaling
-        speedValue *= this.comboPenalty;
+        speedValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.speedDifficultStrainCount);
         // AR scaling
         const calculatedAR = this.difficultyAttributes.approachRate;
         if (calculatedAR > 10.33) {
@@ -3671,9 +3695,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                     750) *
                 Math.pow((this.computedAccuracy.value() +
                     relevantAccuracy.value(this.difficultyAttributes.speedNoteCount)) /
-                    2, (14.5 -
-                    Math.max(this.difficultyAttributes.overallDifficulty, 8)) /
-                    2);
+                    2, (14.5 - this.difficultyAttributes.overallDifficulty) / 2);
         // Scale the speed value with # of 50s to punish doubletapping.
         speedValue *= Math.pow(0.99, Math.max(0, this.computedAccuracy.n50 - this.totalHits / 500));
         return speedValue;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.30",
+    "version": "4.0.0-beta.32",
     "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.30"
+        "@rian8337/osu-base": "^4.0.0-beta.31"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "99b10d7679a476cb5bc87fb91431a6d09ce26ec8"
+    "gitHead": "dd164dcc63fea94501959236d310eccf5a7cda6a"
 }

package/typings/index.d.ts

@@ -80,6 +80,10 @@ interface DifficultyAttributes {
      * The number of spinners in the beatmap.
      */
     spinnerCount: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the aim skill.
+     */
+    aimDifficultStrainCount: number;
 }
 
 /**
@@ -471,6 +475,12 @@ declare abstract class StrainSkill extends Skill {
      * For example, a value of 0.15 indicates that strain decays to 15% of its original value in one second.
      */
     protected abstract readonly strainDecayBase: number;
+    protected readonly _objectStrains: number[];
+    protected difficulty: number;
+    /**
+     * The strains of hitobjects.
+     */
+    get objectStrains(): readonly number[];
     private readonly sectionLength;
     private currentStrain;
     private currentSectionPeak;
@@ -480,6 +490,12 @@ declare abstract class StrainSkill extends Skill {
      * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
      */
     saveCurrentPeak(): void;
+    /**
+     * Returns the number of strains weighed against the top strain.
+     *
+     * The result is scaled by clock rate as it affects the total number of strains.
+     */
+    countDifficultStrains(): number;
     /**
      * Calculates strain decay for a specified time frame.
      *
@@ -529,18 +545,6 @@ declare abstract class DroidSkill extends StrainSkill {
      * The bonus multiplier that is given for a sequence of notes of equal difficulty.
      */
     protected abstract readonly starsPerDouble: number;
-    protected readonly _objectStrains: number[];
-    /**
-     * The strains of hitobjects.
-     */
-    get objectStrains(): readonly number[];
-    private difficulty;
-    /**
-     * Returns the number of strains weighed against the top strain.
-     *
-     * The result is scaled by clock rate as it affects the total number of strains.
-     */
-    countDifficultStrains(): number;
     process(current: DifficultyHitObject): void;
     difficultyValue(): number;
     /**
@@ -702,10 +706,6 @@ interface DroidDifficultyAttributes extends DifficultyAttributes {
      * The difficulty corresponding to the visual skill.
      */
     visualDifficulty: number;
-    /**
-     * The amount of strains that are considered difficult with respect to the aim skill.
-     */
-    aimDifficultStrainCount: number;
     /**
      * The amount of strains that are considered difficult with respect to the tap skill.
      */
@@ -1009,10 +1009,6 @@ declare abstract class PerformanceCalculator<T extends DifficultyAttributes> {
      * The difficulty attributes that is being calculated.
      */
     readonly difficultyAttributes: T;
-    /**
-     * Penalty for combo breaks.
-     */
-    protected comboPenalty: number;
     /**
      * The global multiplier to be applied to the final performance value.
      *
@@ -1073,6 +1069,14 @@ declare abstract class PerformanceCalculator<T extends DifficultyAttributes> {
      * @param options Options for performance calculation.
      */
     protected handleOptions(options?: PerformanceCalculationOptions): void;
+    /**
+     * Calculates a strain-based miss penalty.
+     *
+     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    protected calculateStrainBasedMissPenalty(difficultStrainCount: number): number;
     /**
      * Calculates the amount of misses + sliderbreaks from combo.
      */
@@ -1205,14 +1209,6 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator<DroidDiff
      * Calculates the visual performance value of the beatmap.
      */
     private calculateVisualValue;
-    /**
-     * Calculates a strain-based miss penalty.
-     *
-     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
-     * so we use the amount of relatively difficult sections to adjust miss penalty
-     * to make it more punishing on maps with lower amount of hard sections.
-     */
-    private calculateStrainBasedMissPenalty;
     /**
      * The object-based proportional miss penalty.
      */
@@ -1396,16 +1392,6 @@ declare abstract class DroidVisualEvaluator {
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
  */
 declare abstract class OsuSkill extends StrainSkill {
-    /**
-     * The default multiplier applied to the final difficulty value after all other calculations.
-     *
-     * May be overridden via {@link difficultyMultiplier}.
-     */
-    static readonly defaultDifficultyMultiplier: number;
-    /**
-     * The final multiplier to be applied to the final difficulty value after all other calculations.
-     */
-    protected readonly difficultyMultiplier: number;
     /**
      * The weight by which each strain value decays.
      */
@@ -1434,10 +1420,10 @@ declare class OsuDifficultyHitObject extends DifficultyHitObject {
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 declare class OsuAim extends OsuSkill {
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly decayWeight: number;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly decayWeight = 0.9;
     private currentAimStrain;
     private readonly skillMultiplier;
     private readonly withSliders;
@@ -1482,6 +1468,10 @@ interface OsuDifficultyAttributes extends DifficultyAttributes {
      * The difficulty corresponding to the speed skill.
      */
     speedDifficulty: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the speed skill.
+     */
+    speedDifficultStrainCount: number;
 }
 
 /**
@@ -1551,14 +1541,15 @@ declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuDifficulty
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 declare class OsuFlashlight extends OsuSkill {
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly decayWeight: number;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly decayWeight = 1;
     private currentFlashlightStrain;
     private readonly skillMultiplier;
     private readonly isHidden;
     constructor(mods: Mod[]);
+    difficultyValue(): number;
     protected strainValueAt(current: OsuDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
     protected saveToHitObject(current: OsuDifficultyHitObject): void;
@@ -1604,9 +1595,11 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<OsuDifficul
      */
     flashlight: number;
     protected finalMultiplier: number;
-    protected readonly mode: Modes;
+    protected readonly mode = Modes.osu;
+    private comboPenalty;
     protected calculateValues(): void;
     protected calculateTotalValue(): number;
+    protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
      * Calculates the aim performance value of the beatmap.
      */
@@ -1630,14 +1623,15 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<OsuDifficul
  * An evaluator for calculating osu!standard Rhythm skill.
  */
 declare abstract class OsuRhythmEvaluator {
-    private static readonly rhythmMultiplier;
     private static readonly historyTimeMax;
+    private static readonly historyObjectsMax;
+    private static readonly rhythmOverallMultiplier;
+    private static readonly rhythmRatioMultiplier;
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      */
     static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
 }
@@ -1649,7 +1643,6 @@ declare class OsuSpeed extends OsuSkill {
     protected readonly strainDecayBase = 0.3;
     protected readonly reducedSectionCount = 5;
     protected readonly reducedSectionBaseline = 0.75;
-    protected readonly difficultyMultiplier = 1.04;
     protected readonly decayWeight = 0.9;
     private currentSpeedStrain;
     private currentRhythm;
@@ -1671,8 +1664,11 @@ declare class OsuSpeed extends OsuSkill {
 declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
     /**
      * Spacing threshold for a single hitobject spacing.
+     *
+     * About 1.25 circles distance between hitobject centers.
      */
     private static readonly SINGLE_SPACING_THRESHOLD;
+    private static readonly DISTANCE_MULTIPLIER;
     /**
      * Evaluates the difficulty of tapping the current object, based on:
      *