@rian8337/osu-difficulty-calculator 4.0.0-beta.95 → 4.0.0-beta.97

package/dist/index.js

@@ -60,6 +60,118 @@ class DifficultyCalculator {
             flashlight: skills[3].peaks,
         };
     }
+    /**
+     * Calculates the difficulty of a `Beatmap` with specific `Mod`s and returns a set of
+     * `TimedDifficultyAttributes` representing the difficulty at every relevant time value in the `Beatmap`.
+     *
+     * @param beatmap The `Beatmap` whose difficulty is to be calculated.
+     * @param mods The `Mod`s to apply to the `Beatmap`.
+     * @return The set of `TimedDifficultyAttributes`.
+     */
+    calculateTimed(beatmap, mods) {
+        if (beatmap.hitObjects.objects.length === 0) {
+            return [];
+        }
+        const playableBeatmap = this.createPlayableBeatmap(beatmap, mods);
+        const attributes = osuBase.Utils.initializeArray(beatmap.hitObjects.objects.length);
+        const skills = this.createSkills(playableBeatmap);
+        const progressiveBeatmap = new ProgressiveCalculationBeatmap(playableBeatmap);
+        const { objects } = playableBeatmap.hitObjects;
+        const difficultyObjects = this.createDifficultyHitObjects(playableBeatmap);
+        let currentIndex = 0;
+        for (let i = 0; i < objects.length; ++i) {
+            const obj = objects[i];
+            progressiveBeatmap.hitObjects.add(obj);
+            while (currentIndex < difficultyObjects.length && difficultyObjects[currentIndex].object.endTime <= obj.endTime) {
+                for (const skill of skills) {
+                    skill.process(difficultyObjects[currentIndex]);
+                }
+                ++currentIndex;
+            }
+            attributes[i] = {
+                time: obj.endTime,
+                attributes: this.createDifficultyAttributes(beatmap, playableBeatmap, skills, difficultyObjects.slice(0, currentIndex)),
+                sliderCount: progressiveBeatmap.hitObjects.sliders,
+                sliderTickCount: progressiveBeatmap.hitObjects.sliderTicks,
+                sliderRepeatCount: progressiveBeatmap.hitObjects.sliderRepeatPoints
+            };
+        }
+        return attributes;
+    }
+}
+/**
+ * A {@link PlayableBeatmap} for timed difficulty calculation.
+ */
+class ProgressiveCalculationBeatmap extends osuBase.PlayableBeatmap {
+    get maxCombo() {
+        return this.hitObjects.maxCombo;
+    }
+    constructor(baseBeatmap) {
+        super(baseBeatmap, baseBeatmap.mods);
+        this.hitObjects = new ProgressiveCalculationHitObjects();
+        this.baseHitWindow = baseBeatmap.hitWindow;
+    }
+    createHitWindow() {
+        return this.baseHitWindow;
+    }
+}
+class ProgressiveCalculationHitObjects extends osuBase.BeatmapHitObjects {
+    constructor() {
+        super(...arguments);
+        this.maxCombo = 0;
+        // We store these locally since the super class's getters iterate through all objects, which is inefficient for progressive calculation.
+        this.sliderTickCount = 0;
+        this.sliderRepeatCount = 0;
+    }
+    get sliderTicks() {
+        return this.sliderTickCount;
+    }
+    get sliderRepeatPoints() {
+        return this.sliderRepeatCount;
+    }
+    add(...objects) {
+        super.add(...objects);
+        for (const obj of objects) {
+            if (obj instanceof osuBase.Slider) {
+                this.maxCombo += obj.nestedHitObjects.length;
+                // Similarly, we loop through the nested hit objects since `Slider.ticks` also loops
+                // through the nested hit objects, which is inefficient for progressive calculation.
+                for (const nestedObj of obj.nestedHitObjects) {
+                    if (nestedObj instanceof osuBase.SliderTick) {
+                        ++this.sliderTickCount;
+                    }
+                    else if (nestedObj instanceof osuBase.SliderRepeat) {
+                        ++this.sliderRepeatCount;
+                    }
+                }
+            }
+            else {
+                ++this.maxCombo;
+            }
+        }
+    }
+    removeAt(index) {
+        const obj = super.removeAt(index);
+        if (obj !== null) {
+            if (obj instanceof osuBase.Slider) {
+                this.maxCombo -= obj.nestedHitObjects.length;
+                // Similarly, we loop through the nested hit objects since `Slider.ticks` also loops
+                // through the nested hit objects, which is inefficient for progressive calculation.
+                for (const nestedObj of obj.nestedHitObjects) {
+                    if (nestedObj instanceof osuBase.SliderTick) {
+                        --this.sliderTickCount;
+                    }
+                    else if (nestedObj instanceof osuBase.SliderRepeat) {
+                        --this.sliderRepeatCount;
+                    }
+                }
+            }
+            else {
+                --this.maxCombo;
+            }
+        }
+        return obj;
+    }
 }
 
 /**
@@ -151,11 +263,11 @@ class PerformanceCalculator {
      * @param options Options for performance calculation.
      */
     handleOptions(options) {
-        var _a, _b;
+        var _a, _b, _c;
         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);
-            if (this.computedAccuracy.n300 <= 0) {
+            if (!this.computedAccuracy.isN300Resolved) {
                 this.computedAccuracy.n300 = Math.max(0, this.totalHits -
                     this.computedAccuracy.n100 -
                     this.computedAccuracy.n50 -
@@ -165,16 +277,15 @@ class PerformanceCalculator {
                 this.computedAccuracy.nmiss = Math.max(0, this.totalHits - this.totalSuccessfulHits);
             }
         }
+        else if ((options === null || options === void 0 ? void 0 : options.accPercent) !== undefined) {
+            this.computedAccuracy = osuBase.Accuracy.fromPercent(options.accPercent, this.totalHits, (_a = options.miss) !== null && _a !== void 0 ? _a : 0);
+        }
         else {
-            this.computedAccuracy = new osuBase.Accuracy({
-                percent: options === null || options === void 0 ? void 0 : options.accPercent,
-                nobjects: this.totalHits,
-                nmiss: (_a = options === null || options === void 0 ? void 0 : options.miss) !== null && _a !== void 0 ? _a : 0,
-            });
+            this.computedAccuracy = osuBase.Accuracy.fromHitCounts({ nmiss: (_b = options === null || options === void 0 ? void 0 : options.miss) !== null && _b !== void 0 ? _b : 0 }, this.totalHits);
         }
         const maxCombo = this.difficultyAttributes.maxCombo;
         const miss = this.computedAccuracy.nmiss;
-        this.combo = (_b = options === null || options === void 0 ? void 0 : options.combo) !== null && _b !== void 0 ? _b : maxCombo - miss;
+        this.combo = (_c = options === null || options === void 0 ? void 0 : options.combo) !== null && _c !== void 0 ? _c : maxCombo - miss;
         if ((options === null || options === void 0 ? void 0 : options.sliderEndsDropped) !== undefined &&
             options.sliderTicksMissed !== undefined) {
             this._usingClassicSliderAccuracy = false;
@@ -3389,15 +3500,16 @@ class DroidScoreUtils {
     /**
      * Calculates the maximum possible spinner bonus for a given beatmap.
      *
-     * @param beatmap The beatmap to calculate the maximum spinner bonus for.
+     * @param beatmap The `Beatmap` to calculate the maximum spinner bonus for.
+     * @param playableBeatmap The `DroidPlayableBeatmap` to calculate the maximum spinner bonus for.
      * @returns The maximum spinner bonus.
      */
-    static calculateMaximumSpinnerBonus(beatmap) {
-        const { hitObjects } = beatmap;
+    static calculateMaximumSpinnerBonus(beatmap, playableBeatmap) {
+        const { hitObjects } = playableBeatmap;
         if (hitObjects.spinners === 0) {
             return 0;
         }
-        const scoreMultiplier = osuBase.ModUtil.calculateScoreMultiplier(beatmap.mods.values(), osuBase.Modes.Droid);
+        const scoreMultiplier = new osuBase.DroidScoreMultiplierCalculator(beatmap.difficulty).calculateFor(playableBeatmap.mods.values());
         let bonus = 0;
         // In osu!droid, there is no time-based limit to spinner RPM, since the limit is
         // π/2 rad/*frame* and not rad/second.
@@ -3406,7 +3518,7 @@ class DroidScoreUtils {
         // the actual maximum spinner bonus.
         const maximumRotationsPerSecond = (Math.PI / 2) * 120;
         // Taken from https://github.com/osudroid/osu-droid/blob/45ae4d66ce275382c5de037245ceca8704b3ae75/src/ru/nsu/ccfit/zuev/osu/game/GameScene.java#L1640.
-        const minimumRotationsPerSecond = 2 + (2 * beatmap.difficulty.od) / 10;
+        const minimumRotationsPerSecond = 2 + (2 * playableBeatmap.difficulty.od) / 10;
         for (const obj of hitObjects.objects) {
             if (!(obj instanceof osuBase.Spinner)) {
                 continue;
@@ -3449,8 +3561,9 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         attributes.overallDifficulty = playableBeatmap.difficulty.od;
         // 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);
+        attributes.maximumScore =
+            beatmap.maxDroidScore(playableBeatmap.mods) +
+                DroidScoreUtils.calculateMaximumSpinnerBonus(beatmap, playableBeatmap);
         this.populateAimAttributes(attributes, skills, objects);
         this.populateTapAttributes(attributes, skills, objects);
         this.populateRhythmAttributes(attributes, skills);
@@ -5025,7 +5138,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                 1.3 +
                     this.totalHits *
                         (0.0016 / (1 + 2 * this._effectiveMissCount)) *
-                        Math.pow(this.computedAccuracy.value(), 16) *
+                        Math.pow(this.computedAccuracy.value, 16) *
                         (1 -
                             0.003 *
                                 Math.pow(this.difficultyAttributes.drainRate, 2));
@@ -5036,7 +5149,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                     this.calculateTraceableBonus(this.difficultyAttributes.sliderFactor);
         }
         // Scale the aim value with accuracy.
-        aimValue *= this.computedAccuracy.value();
+        aimValue *= this.computedAccuracy.value;
         return aimValue;
     }
     /**
@@ -5085,7 +5198,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
         let accuracyValue = Math.pow(1.52163, this.overallDifficulty) *
             // It is possible to reach a negative accuracy with this formula. Cap it at zero - zero points.
-            Math.pow(realAccuracy.n300 < 0 ? 0 : realAccuracy.value(), 24) *
+            Math.pow(realAccuracy.n300 < 0 ? 0 : realAccuracy.value, 24) *
             2.83;
         // Bonus for many hitcircles - it's harder to keep good accuracy up for longer.
         accuracyValue *= Math.pow(ncircles / 1000, ncircles < 1000 ? 0.3 : 0.1);
@@ -5119,7 +5232,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                         Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
         }
         // Scale the flashlight value with accuracy slightly.
-        flashlightValue *= 0.5 + this.computedAccuracy.value() / 2;
+        flashlightValue *= 0.5 + this.computedAccuracy.value / 2;
         return flashlightValue;
     }
     /**
@@ -5132,7 +5245,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             readingValue *= this.calculateMissPenalty(this.effectiveMissCount + aimEstimatedSliderBreaks, this.difficultyAttributes.readingDifficultNoteCount);
         }
         // Scale the reading value with accuracy _harshly_.
-        readingValue *= Math.pow(this.computedAccuracy.value(), 3);
+        readingValue *= Math.pow(this.computedAccuracy.value, 3);
         return readingValue;
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.95",
+    "version": "4.0.0-beta.97",
     "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.95"
+        "@rian8337/osu-base": "4.0.0-beta.97"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "b07790be9c9dd737170d2d576bf02298ec607ab9"
+    "gitHead": "0d77ee41c1b0eca8e46c118e942417483c4a9452"
 }

package/typings/index.d.ts

@@ -445,6 +445,34 @@ declare abstract class Skill {
     protected abstract processInternal(current: DifficultyHitObject): number;
 }
 
+/**
+ * Wraps a `DifficultyAttributes` object and adds a time value for which the attribute is valid.
+ *
+ * Output by `DifficultyCalculator.calculateTimed` methods.
+ */
+interface TimedDifficultyAttributes<TAttributes extends DifficultyAttributes> {
+    /**
+     * The non-clock-adjusted time value at which the attributes take effect.
+     */
+    readonly time: number;
+    /**
+     * The attributes.
+     */
+    readonly attributes: TAttributes;
+    /**
+     * The number of sliders in the beatmap up to this point.
+     */
+    readonly sliderCount: number;
+    /**
+     * The number of slider ticks in the beatmap up to this point.
+     */
+    readonly sliderTickCount: number;
+    /**
+     * The number of slider repeats in the beatmap up to this point.
+     */
+    readonly sliderRepeatCount: number;
+}
+
 /**
  * The base of a difficulty calculator.
  */
@@ -483,6 +511,15 @@ declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, TH
      * @returns The strain peaks of the `Beatmap`.
      */
     calculateStrainPeaks(beatmap: Beatmap, mods?: ModMap): StrainPeaks;
+    /**
+     * Calculates the difficulty of a `Beatmap` with specific `Mod`s and returns a set of
+     * `TimedDifficultyAttributes` representing the difficulty at every relevant time value in the `Beatmap`.
+     *
+     * @param beatmap The `Beatmap` whose difficulty is to be calculated.
+     * @param mods The `Mod`s to apply to the `Beatmap`.
+     * @return The set of `TimedDifficultyAttributes`.
+     */
+    calculateTimed(beatmap: Beatmap, mods?: ModMap): TimedDifficultyAttributes<TAttributes>[];
     /**
      * Creates the `Skill`s to calculate the difficulty of a `PlayableBeatmap`.
      *
@@ -2053,4 +2090,4 @@ declare class OsuSpeed extends HarmonicSkill {
 }
 
 export { DifficultyAttributes, DifficultyCalculator, DifficultyHitObject, DroidAgilityEvaluator, DroidAim, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidFlowAimEvaluator, DroidPerformanceCalculator, DroidReading, DroidReadingEvaluator, DroidRhythm, DroidRhythmEvaluator, DroidSnapAimEvaluator, DroidTap, DroidTapEvaluator, ExtendedDroidDifficultyAttributes, OsuAgilityEvaluator, OsuAim, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuFlowAimEvaluator, OsuPerformanceCalculator, OsuReading, OsuReadingEvaluator, OsuRhythmEvaluator, OsuSnapAimEvaluator, OsuSpeed, OsuSpeedEvaluator, PerformanceCalculator };
-export type { CacheableDifficultyAttributes, DifficultSlider, HighStrainSection, IDifficultyAttributes, IDroidDifficultyAttributes, IExtendedDroidDifficultyAttributes, IOsuDifficultyAttributes, PerformanceCalculationOptions, StrainPeaks, TimedStrainPeak };
+export type { CacheableDifficultyAttributes, DifficultSlider, HighStrainSection, IDifficultyAttributes, IDroidDifficultyAttributes, IExtendedDroidDifficultyAttributes, IOsuDifficultyAttributes, PerformanceCalculationOptions, StrainPeaks, TimedDifficultyAttributes, TimedStrainPeak };