@rian8337/osu-difficulty-calculator 4.0.0-beta.92 → 4.0.0-beta.93

package/dist/index.js

@@ -223,8 +223,17 @@ class Skill {
     get objectDifficulties() {
         return this._objectDifficulties;
     }
+    /**
+     * The start times of {@link DifficultyHitObject}s, populated by {@link Skill.process}.
+     *
+     * Indices correspond to {@link objectDifficulties}.
+     */
+    get objectTimes() {
+        return this._objectTimes;
+    }
     constructor(mods) {
         this._objectDifficulties = [];
+        this._objectTimes = [];
         this.mods = mods;
     }
     /**
@@ -240,6 +249,7 @@ class Skill {
         const difficultyValue = this.processInternal(current);
         this.saveToHitObject(current, difficultyValue);
         this._objectDifficulties.push(difficultyValue);
+        this._objectTimes.push(current.startTime);
     }
     /**
      * Saves the calculated difficulty to a {@link DifficultyHitObject}.
@@ -276,6 +286,12 @@ class VariableLengthStrainSkill extends Skill {
         this.currentSectionEnd = 0;
         this.totalLength = 0;
         this.strainPeaks = [];
+        /**
+         * The peaks of this skill in chronological order, used for graphing purposes.
+         *
+         * Unlike {@link strainPeaks}, this is never trimmed, as it does not contribute to {@link difficultyValue}.
+         */
+        this.chronologicalPeaks = [];
         /**
          * Stores previous strains so that, if a difficult {@link DifficultyHitObject} is followed by an easier
          * {@link DifficultyHitObject}, the difficult one gets a full strain instead of being cut short.
@@ -294,7 +310,10 @@ class VariableLengthStrainSkill extends Skill {
         return 11 / (1 - this.decayWeight);
     }
     get peaks() {
-        return this.currentStrainPeaks.map((s) => s.value);
+        return this.chronologicalPeaks.concat({
+            time: this.currentSectionEnd,
+            value: this.currentSectionPeak,
+        });
     }
     static difficultyToPerformance(difficulty) {
         return 4 * Math.pow(difficulty, 3);
@@ -442,6 +461,10 @@ class VariableLengthStrainSkill extends Skill {
      */
     saveCurrentPeak(sectionLength) {
         this.addStrainPeakInPlace(new StrainPeak(this.currentSectionPeak, sectionLength));
+        this.chronologicalPeaks.push({
+            time: this.currentSectionBegin + sectionLength,
+            value: this.currentSectionPeak,
+        });
         this.totalLength += sectionLength;
         // Remove from the front of our strain peaks if there is any which are too deep to contribute to difficulty.
         // `maxStoredSections` dictates for us how many sections will preserve at least 99.999% of difficulty.
@@ -1095,6 +1118,7 @@ class StrainSkill extends Skill {
         this.reducedSectionBaseline = 0.75;
         this._objectStrains = [];
         this.strainPeaks = [];
+        this.strainPeakTimes = [];
         this.sectionLength = 400;
         this.currentStrain = 0;
         this.currentSectionPeak = 0;
@@ -1107,7 +1131,9 @@ class StrainSkill extends Skill {
         return this._objectStrains;
     }
     get peaks() {
-        return this.currentStrainPeaks;
+        return this.strainPeaks
+            .map((value, i) => ({ time: this.strainPeakTimes[i], value }))
+            .concat({ time: this.currentSectionEnd, value: this.currentSectionPeak });
     }
     /**
      * Converts a difficulty value to a performance value.
@@ -1175,6 +1201,7 @@ class StrainSkill extends Skill {
      */
     saveCurrentPeak() {
         this.strainPeaks.push(this.currentSectionPeak);
+        this.strainPeakTimes.push(this.currentSectionEnd);
     }
     /**
      * Sets the initial strain level for a new section.
@@ -1278,7 +1305,7 @@ class DroidFlashlight extends DroidSkill {
         return sum;
     }
     calculateAdjustedDifficulty(current) {
-        let difficulty = Math.pow(DroidFlashlightEvaluator.evaluateDifficultyOf(current, this.mods), 0.8);
+        let difficulty = Math.pow(DroidFlashlightEvaluator.evaluateDifficultyOf(current, this.mods), 0.9);
         if (this.mods.has(osuBase.ModRelax)) {
             difficulty *= 0.7;
         }
@@ -1322,7 +1349,10 @@ class HarmonicSkill extends Skill {
         return this._noteWeightSum;
     }
     get peaks() {
-        return this.objectDifficulties;
+        return this.objectDifficulties.map((value, i) => ({
+            time: this.objectTimes[i],
+            value,
+        }));
     }
     static difficultyToPerformance(difficulty) {
         return 4 * Math.pow(difficulty, 3);
@@ -3161,9 +3191,15 @@ class DroidRhythmEvaluator {
                     // Scale down the difficulty if the object is doubletappable.
                     effectiveRatio *=
                         1 - prevObject.getDoubletapness(currentObject) * 0.75;
-                    rhythmComplexitySum +=
-                        Math.sqrt(effectiveRatio * startRatio) *
-                            currentHistoricalDecay;
+                    if (island.deltaCount > 1) {
+                        rhythmComplexitySum +=
+                            Math.sqrt(effectiveRatio * startRatio) *
+                                currentHistoricalDecay;
+                    }
+                    else {
+                        // Constant difficulty for single-note islands.
+                        rhythmComplexitySum += 0.7 * currentHistoricalDecay;
+                    }
                     startRatio = effectiveRatio;
                     previousIsland = island;
                     if (prevDelta + deltaDifferenceEpsilon < currentDelta) {
@@ -3419,9 +3455,10 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         attributes.sliderCount = playableBeatmap.hitObjects.sliders;
         attributes.spinnerCount = playableBeatmap.hitObjects.spinners;
         attributes.overallDifficulty = playableBeatmap.difficulty.od;
-        attributes.maximumScore =
-            beatmap.maxDroidScore(playableBeatmap.mods) +
-                DroidScoreUtils.calculateMaximumSpinnerBonus(playableBeatmap);
+        // Cap at 32-bit signed integer since that's the maximum score that can be submitted
+        // to the game's leaderboards.
+        attributes.maximumScore = Math.min(beatmap.maxDroidScore(playableBeatmap.mods) +
+            DroidScoreUtils.calculateMaximumSpinnerBonus(playableBeatmap), 2147483647);
         this.populateAimAttributes(attributes, skills, objects);
         this.populateTapAttributes(attributes, skills, objects);
         this.populateRhythmAttributes(attributes, skills);
@@ -3494,8 +3531,9 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         attributes.aimDifficultSliderCount = aim.countDifficultSliders();
         attributes.aimDifficultStrainCount =
             aim.countTopWeightedStrains(aimDifficultyValue);
-        const aimNoSliderTopWeightedSliderCount = aimNoSlider.countTopWeightedSliders(aimDifficultyValue);
-        const aimNoSliderDifficultStrainCount = aimNoSlider.countTopWeightedStrains(aimDifficultyValue);
+        const aimNoSliderDifficultyValue = aimNoSlider.difficultyValue();
+        const aimNoSliderTopWeightedSliderCount = aimNoSlider.countTopWeightedSliders(aimNoSliderDifficultyValue);
+        const aimNoSliderDifficultStrainCount = aimNoSlider.countTopWeightedStrains(aimNoSliderDifficultyValue);
         attributes.aimTopWeightedSliderFactor =
             aimNoSliderTopWeightedSliderCount /
                 Math.max(1, aimNoSliderDifficultStrainCount -
@@ -3530,7 +3568,8 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         }
         if (attributes.aimDifficulty > 0) {
             attributes.sliderFactor =
-                this.calculateAimDifficultyRating(aimNoSlider.difficultyValue()) / this.calculateAimDifficultyRating(aimDifficultyValue);
+                this.calculateAimDifficultyRating(aimNoSliderDifficultyValue) /
+                    this.calculateAimDifficultyRating(aimDifficultyValue);
         }
         else {
             attributes.sliderFactor = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.92",
+    "version": "4.0.0-beta.93",
     "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": "102e7baf7e9179caf6b0e81cafb53d6e3a561184"
+    "gitHead": "9eee7ed61799bd3d1a9510e0491e7433932ba190"
 }

package/typings/index.d.ts

@@ -336,6 +336,20 @@ declare abstract class DifficultyAttributes implements IDifficultyAttributes {
     toString(): string;
 }
 
+/**
+ * Represents a strain peak at a specific point in time.
+ */
+interface TimedStrainPeak {
+    /**
+     * The time at which this peak occurs, in milliseconds.
+     */
+    readonly time: number;
+    /**
+     * The strain value of this peak.
+     */
+    readonly value: number;
+}
+
 /**
  * Represents the strain peaks of various calculated difficulties.
  */
@@ -343,19 +357,19 @@ interface StrainPeaks {
     /**
      * The strain peaks of aim difficulty if sliders are considered.
      */
-    aimWithSliders: readonly number[];
+    aimWithSliders: readonly TimedStrainPeak[];
     /**
      * The strain peaks of aim difficulty if sliders are not considered.
      */
-    aimWithoutSliders: readonly number[];
+    aimWithoutSliders: readonly TimedStrainPeak[];
     /**
      * The strain peaks of speed difficulty.
      */
-    speed: readonly number[];
+    speed: readonly TimedStrainPeak[];
     /**
      * The strain peaks of flashlight difficulty.
      */
-    flashlight: readonly number[];
+    flashlight: readonly TimedStrainPeak[];
 }
 
 /**
@@ -363,9 +377,9 @@ interface StrainPeaks {
  */
 interface IHasPeakDifficulty {
     /**
-     * The peak difficulties calculated by this `Skill`.
+     * The peak difficulties calculated by this `Skill`, in chronological order.
      */
-    get peaks(): readonly number[];
+    get peaks(): readonly TimedStrainPeak[];
 }
 
 /**
@@ -377,10 +391,17 @@ declare abstract class Skill {
      */
     protected readonly mods: ModMap;
     private _objectDifficulties;
+    private _objectTimes;
     /**
      * The difficulties of {@link DifficultyHitObject}s, populated by {@link Skill.process}.
      */
     protected get objectDifficulties(): readonly number[];
+    /**
+     * The start times of {@link DifficultyHitObject}s, populated by {@link Skill.process}.
+     *
+     * Indices correspond to {@link objectDifficulties}.
+     */
+    protected get objectTimes(): readonly number[];
     constructor(mods: ModMap);
     /**
      * Calculates the strain value of a hitobject and stores the value in it.
@@ -1263,7 +1284,8 @@ declare abstract class StrainSkill extends Skill implements IHasPeakDifficulty {
      */
     get objectStrains(): readonly number[];
     protected readonly strainPeaks: number[];
-    get peaks(): readonly number[];
+    private readonly strainPeakTimes;
+    get peaks(): readonly TimedStrainPeak[];
     private readonly sectionLength;
     private currentStrain;
     private currentSectionPeak;
@@ -1531,7 +1553,13 @@ declare abstract class VariableLengthStrainSkill extends Skill implements IHasPe
     private currentSectionEnd;
     private totalLength;
     private readonly strainPeaks;
-    get peaks(): readonly number[];
+    /**
+     * The peaks of this skill in chronological order, used for graphing purposes.
+     *
+     * Unlike {@link strainPeaks}, this is never trimmed, as it does not contribute to {@link difficultyValue}.
+     */
+    private readonly chronologicalPeaks;
+    get peaks(): readonly TimedStrainPeak[];
     /**
      * Stores previous strains so that, if a difficult {@link DifficultyHitObject} is followed by an easier
      * {@link DifficultyHitObject}, the difficult one gets a full strain instead of being cut short.
@@ -1706,7 +1734,7 @@ declare abstract class HarmonicSkill extends Skill implements IHasPeakDifficulty
      * Values closer to 1 decay faster, whilst lower values give more weight to easier {@link DifficultyHitObject}s.
      */
     protected readonly decayExponent: number;
-    get peaks(): readonly number[];
+    get peaks(): readonly TimedStrainPeak[];
     static difficultyToPerformance(difficulty: number): number;
     difficultyValue(): number;
     /**
@@ -1878,4 +1906,4 @@ declare class OsuSpeed extends OsuSkill {
 }
 
 export { DifficultyAttributes, DifficultyCalculator, DifficultyHitObject, DroidAgilityEvaluator, DroidAim, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidFlowAimEvaluator, DroidPerformanceCalculator, DroidReading, DroidReadingEvaluator, DroidRhythm, DroidRhythmEvaluator, DroidSnapAimEvaluator, DroidTap, DroidTapEvaluator, ExtendedDroidDifficultyAttributes, OsuAim, OsuAimEvaluator, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, PerformanceCalculator };
-export type { CacheableDifficultyAttributes, DifficultSlider, HighStrainSection, IDifficultyAttributes, IDroidDifficultyAttributes, IExtendedDroidDifficultyAttributes, IOsuDifficultyAttributes, PerformanceCalculationOptions, StrainPeaks };
+export type { CacheableDifficultyAttributes, DifficultSlider, HighStrainSection, IDifficultyAttributes, IDroidDifficultyAttributes, IExtendedDroidDifficultyAttributes, IOsuDifficultyAttributes, PerformanceCalculationOptions, StrainPeaks, TimedStrainPeak };