@rian8337/osu-difficulty-calculator 4.0.0-beta.12 → 4.0.0-beta.14

package/dist/index.js

@@ -29,7 +29,7 @@ class AimEvaluator {
 }
 
 /**
- * Represents an osu!standard hit object with difficulty calculation values.
+ * Represents a hit object with difficulty calculation values.
  */
 class DifficultyHitObject {
     /**
@@ -62,41 +62,10 @@ class DifficultyHitObject {
      * The aim strain generated by the hitobject if sliders are not considered.
      */
     aimStrainWithoutSliders = 0;
-    /**
-     * The tap strain generated by the hitobject.
-     *
-     * This is also used for osu!standard as opposed to "speed strain".
-     */
-    tapStrain = 0;
-    /**
-     * The tap strain generated by the hitobject if `strainTime` isn't modified by
-     * OD. This is used in three-finger detection.
-     */
-    originalTapStrain = 0;
     /**
      * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
      */
     rhythmMultiplier = 0;
-    /**
-     * The rhythm strain generated by the hitobject.
-     */
-    rhythmStrain = 0;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are considered.
-     */
-    flashlightStrainWithSliders = 0;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are not considered.
-     */
-    flashlightStrainWithoutSliders = 0;
-    /**
-     * The visual strain generated by the hitobject if sliders are considered.
-     */
-    visualStrainWithSliders = 0;
-    /**
-     * The visual strain generated by the hitobject if sliders are not considered.
-     */
-    visualStrainWithoutSliders = 0;
     /**
      * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
      *
@@ -150,20 +119,6 @@ class DifficultyHitObject {
      * Adjusted end time of the hitobject, taking speed multiplier into account.
      */
     endTime = 0;
-    /**
-     * The note density of the hitobject.
-     */
-    noteDensity = 1;
-    /**
-     * The overlapping factor of the hitobject.
-     *
-     * This is used to scale visual skill.
-     */
-    overlappingFactor = 0;
-    /**
-     * Adjusted velocity of the hitobject, taking speed multiplier into account.
-     */
-    velocity = 0;
     /**
      * Other hitobjects in the beatmap, including this hitobject.
      */
@@ -200,7 +155,7 @@ class DifficultyHitObject {
      * difficulty hitobject's index, `null` if the index is out of range.
      */
     next(forwardsIndex) {
-        return this.hitObjects[this.index + forwardsIndex + 2] ?? null;
+        return (this.hitObjects[this.index + forwardsIndex + 2] ?? null);
     }
     /**
      * Calculates the opacity of the hitobject at a given time.
@@ -261,6 +216,79 @@ class DifficultyHitObject {
     }
 }
 
+/**
+ * Represents an osu!droid hit object with difficulty calculation values.
+ */
+class DroidDifficultyHitObject extends DifficultyHitObject {
+    /**
+     * The tap strain generated by the hitobject.
+     */
+    tapStrain = 0;
+    /**
+     * The tap strain generated by the hitobject if `strainTime` isn't modified by
+     * OD. This is used in three-finger detection.
+     */
+    originalTapStrain = 0;
+    /**
+     * The rhythm strain generated by the hitobject.
+     */
+    rhythmStrain = 0;
+    /**
+     * The flashlight strain generated by the hitobject if sliders are considered.
+     */
+    flashlightStrainWithSliders = 0;
+    /**
+     * The flashlight strain generated by the hitobject if sliders are not considered.
+     */
+    flashlightStrainWithoutSliders = 0;
+    /**
+     * The visual strain generated by the hitobject if sliders are considered.
+     */
+    visualStrainWithSliders = 0;
+    /**
+     * The visual strain generated by the hitobject if sliders are not considered.
+     */
+    visualStrainWithoutSliders = 0;
+    /**
+     * The note density of the hitobject.
+     */
+    noteDensity = 1;
+    /**
+     * The overlapping factor of the hitobject.
+     *
+     * This is used to scale visual skill.
+     */
+    overlappingFactor = 0;
+    /**
+     * @param object The underlying hitobject.
+     * @param hitObjects All difficulty hitobjects in the processed beatmap.
+     */
+    constructor(object, hitObjects) {
+        super(object, hitObjects);
+    }
+}
+
+/**
+ * Represents an osu!standard hit object with difficulty calculation values.
+ */
+class OsuDifficultyHitObject extends DifficultyHitObject {
+    /**
+     * The speed strain generated by the hitobject.
+     */
+    speedStrain = 0;
+    /**
+     * The flashlight strain generated by this hitobject.
+     */
+    flashlightStrain = 0;
+    /**
+     * @param object The underlying hitobject.
+     * @param hitObjects All difficulty hitobjects in the processed beatmap.
+     */
+    constructor(object, hitObjects) {
+        super(object, hitObjects);
+    }
+}
+
 /**
  * A converter used to convert normal hitobjects into difficulty hitobjects.
  */
@@ -284,9 +312,6 @@ class DifficultyHitObjectCreator {
     maximumSliderRadius = this.normalizedRadius * 2.4;
     assumedSliderRadius = this.normalizedRadius * 1.8;
     minDeltaTime = 25;
-    /**
-     * Generates difficulty hitobjects for difficulty calculation.
-     */
     generateDifficultyObjects(params) {
         params.preempt ??= 600;
         this.mode = params.mode;
@@ -296,13 +321,13 @@ class DifficultyHitObjectCreator {
         const scalingFactor = this.getScalingFactor(params.objects[0].getRadius(this.mode));
         const difficultyObjects = [];
         for (let i = 0; i < params.objects.length; ++i) {
-            const object = new DifficultyHitObject(params.objects[i], difficultyObjects);
+            const object = this.mode === osuBase.Modes.droid
+                ? new DroidDifficultyHitObject(params.objects[i], difficultyObjects)
+                : new OsuDifficultyHitObject(params.objects[i], difficultyObjects);
             object.index = difficultyObjects.length - 1;
             object.timePreempt = params.preempt;
             object.baseTimePreempt = params.preempt * params.speedMultiplier;
             if (object.object instanceof osuBase.Slider) {
-                object.velocity =
-                    object.object.velocity * params.speedMultiplier;
                 this.calculateSliderCursorPosition(object.object);
                 object.travelDistance = object.object.lazyTravelDistance;
                 // Bonus for repeat sliders until a better per nested object strain system can be achieved.
@@ -331,53 +356,57 @@ class DifficultyHitObjectCreator {
                 difficultyObjects.push(object);
                 continue;
             }
-            // We'll have two visible object arrays. The first array contains objects before the current object starts in a reversed order,
-            // while the second array contains objects after the current object ends.
-            // For overlapping factor, we also need to consider previous visible objects.
-            const prevVisibleObjects = [];
-            const nextVisibleObjects = [];
-            for (let j = i + 1; j < params.objects.length; ++j) {
-                const o = params.objects[j];
-                if (o instanceof osuBase.Spinner) {
-                    continue;
-                }
-                if (o.startTime / params.speedMultiplier >
-                    object.endTime + object.timePreempt) {
-                    break;
-                }
-                nextVisibleObjects.push(o);
-            }
-            for (let j = 0; j < object.index; ++j) {
-                const prev = object.previous(j);
-                if (prev.object instanceof osuBase.Spinner) {
-                    continue;
+            if (object instanceof DroidDifficultyHitObject) {
+                // We'll have two visible object arrays. The first array contains objects before the current object starts in a reversed order,
+                // while the second array contains objects after the current object ends.
+                // For overlapping factor, we also need to consider previous visible objects.
+                const prevVisibleObjects = [];
+                const nextVisibleObjects = [];
+                for (let j = i + 1; j < params.objects.length; ++j) {
+                    const o = params.objects[j];
+                    if (o instanceof osuBase.Spinner) {
+                        continue;
+                    }
+                    if (o.startTime / params.speedMultiplier >
+                        object.endTime + object.timePreempt) {
+                        break;
+                    }
+                    nextVisibleObjects.push(o);
                 }
-                if (prev.startTime >= object.startTime) {
-                    continue;
+                for (let j = 0; j < object.index; ++j) {
+                    const prev = object.previous(j);
+                    if (prev.object instanceof osuBase.Spinner) {
+                        continue;
+                    }
+                    if (prev.startTime >= object.startTime) {
+                        continue;
+                    }
+                    if (prev.startTime <
+                        object.startTime - object.timePreempt) {
+                        break;
+                    }
+                    prevVisibleObjects.push(prev.object);
                 }
-                if (prev.startTime < object.startTime - object.timePreempt) {
-                    break;
+                for (const hitObject of prevVisibleObjects) {
+                    const distance = object.object
+                        .getStackedPosition(this.mode)
+                        .getDistance(hitObject.getStackedEndPosition(this.mode));
+                    const deltaTime = object.startTime -
+                        hitObject.endTime / params.speedMultiplier;
+                    this.applyToOverlappingFactor(object, distance, deltaTime);
                 }
-                prevVisibleObjects.push(prev.object);
-            }
-            for (const hitObject of prevVisibleObjects) {
-                const distance = object.object
-                    .getStackedPosition(this.mode)
-                    .getDistance(hitObject.getStackedEndPosition(this.mode));
-                const deltaTime = object.startTime -
-                    hitObject.endTime / params.speedMultiplier;
-                this.applyToOverlappingFactor(object, distance, deltaTime);
-            }
-            for (const hitObject of nextVisibleObjects) {
-                const distance = hitObject
-                    .getStackedPosition(this.mode)
-                    .getDistance(object.object.getStackedEndPosition(this.mode));
-                const deltaTime = hitObject.startTime / params.speedMultiplier -
-                    object.endTime;
-                if (deltaTime >= 0) {
-                    object.noteDensity += 1 - deltaTime / object.timePreempt;
+                for (const hitObject of nextVisibleObjects) {
+                    const distance = hitObject
+                        .getStackedPosition(this.mode)
+                        .getDistance(object.object.getStackedEndPosition(this.mode));
+                    const deltaTime = hitObject.startTime / params.speedMultiplier -
+                        object.endTime;
+                    if (deltaTime >= 0) {
+                        object.noteDensity +=
+                            1 - deltaTime / object.timePreempt;
+                    }
+                    this.applyToOverlappingFactor(object, distance, deltaTime);
                 }
-                this.applyToOverlappingFactor(object, distance, deltaTime);
             }
             if (lastObject.object instanceof osuBase.Spinner) {
                 difficultyObjects.push(object);
@@ -1606,6 +1635,31 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         difficultSliders: [],
         averageSpeedDeltaTime: 0,
     };
+    get cacheableAttributes() {
+        return {
+            tapDifficulty: this.tap,
+            rhythmDifficulty: this.rhythm,
+            visualDifficulty: this.visual,
+            mods: osuBase.ModUtil.modsToOsuString(this.attributes.mods),
+            starRating: this.total,
+            maxCombo: this.attributes.maxCombo,
+            aimDifficulty: this.aim,
+            flashlightDifficulty: this.flashlight,
+            speedNoteCount: this.attributes.speedNoteCount,
+            sliderFactor: this.attributes.sliderFactor,
+            clockRate: this.attributes.clockRate,
+            approachRate: this.attributes.approachRate,
+            overallDifficulty: this.attributes.overallDifficulty,
+            hitCircleCount: this.attributes.hitCircleCount,
+            sliderCount: this.attributes.sliderCount,
+            spinnerCount: this.attributes.spinnerCount,
+            aimDifficultStrainCount: this.attributes.aimDifficultStrainCount,
+            tapDifficultStrainCount: this.attributes.tapDifficultStrainCount,
+            flashlightDifficultStrainCount: this.attributes.flashlightDifficultStrainCount,
+            visualDifficultStrainCount: this.attributes.visualDifficultStrainCount,
+            averageSpeedDeltaTime: this.attributes.averageSpeedDeltaTime,
+        };
+    }
     difficultyMultiplier = 0.18;
     mode = osuBase.Modes.droid;
     /**
@@ -1693,7 +1747,6 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         const visualSkillWithoutSliders = skills[8];
         this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
         this.postCalculateTap(tapSkillCheese);
-        this.calculateTapAttributes();
         this.postCalculateRhythm(rhythmSkill);
         this.postCalculateFlashlight(flashlightSkill, flashlightSkillWithoutSliders);
         this.postCalculateVisual(visualSkill, visualSkillWithoutSliders);
@@ -1992,6 +2045,10 @@ class PerformanceCalculator {
      * The calculated accuracy.
      */
     computedAccuracy = new osuBase.Accuracy({});
+    /**
+     * The difficulty attributes that is being calculated.
+     */
+    difficultyAttributes;
     /**
      * Penalty for combo breaks.
      */
@@ -2004,6 +2061,20 @@ class PerformanceCalculator {
      * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
      */
     sliderNerfFactor = 1;
+    /**
+     * @param difficultyAttributes The difficulty attributes to calculate.
+     */
+    constructor(difficultyAttributes) {
+        if (this.isCacheableAttribute(difficultyAttributes)) {
+            this.difficultyAttributes = {
+                ...difficultyAttributes,
+                mods: osuBase.ModUtil.pcStringToMods(difficultyAttributes.mods),
+            };
+        }
+        else {
+            this.difficultyAttributes = osuBase.Utils.deepCopy(difficultyAttributes);
+        }
+    }
     /**
      * Calculates the performance points of the beatmap.
      *
@@ -2127,6 +2198,15 @@ class PerformanceCalculator {
         }
         return Math.max(this.computedAccuracy.nmiss, comboBasedMissCount);
     }
+    /**
+     * Determines whether an attribute is a cacheable attribute.
+     *
+     * @param attributes The attributes to check.
+     * @returns Whether the attributes are cacheable.
+     */
+    isCacheableAttribute(attributes) {
+        return typeof attributes.mods === "string";
+    }
 }
 
 /**
@@ -2197,7 +2277,6 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
     get visualSliderCheesePenalty() {
         return this._visualSliderCheesePenalty;
     }
-    difficultyAttributes;
     finalMultiplier = 1.24;
     mode = osuBase.Modes.droid;
     _aimSliderCheesePenalty = 1;
@@ -2206,13 +2285,6 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
     _tapPenalty = 1;
     _deviation = 0;
     _tapDeviation = 0;
-    /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
-     */
-    constructor(difficultyAttributes) {
-        super();
-        this.difficultyAttributes = osuBase.Utils.deepCopy(difficultyAttributes);
-    }
     /**
      * Applies a tap penalty value to this calculator.
      *
@@ -3021,7 +3093,7 @@ class OsuSpeed extends OsuSkill {
      * @param current The hitobject to save to.
      */
     saveToHitObject(current) {
-        current.tapStrain = this.currentSpeedStrain * this.currentRhythm;
+        current.speedStrain = this.currentSpeedStrain * this.currentRhythm;
         current.rhythmMultiplier = this.currentRhythm;
     }
 }
@@ -3134,7 +3206,7 @@ class OsuFlashlight extends OsuSkill {
             this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
     }
     saveToHitObject(current) {
-        current.flashlightStrainWithSliders = this.currentFlashlightStrain;
+        current.flashlightStrain = this.currentFlashlightStrain;
     }
 }
 
@@ -3170,6 +3242,12 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         sliderCount: 0,
         spinnerCount: 0,
     };
+    get cacheableAttributes() {
+        return {
+            ...this.attributes,
+            mods: osuBase.ModUtil.modsToOsuString(this.attributes.mods),
+        };
+    }
     difficultyMultiplier = 0.0675;
     mode = osuBase.Modes.osu;
     /**
@@ -3309,7 +3387,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
      * Calculates speed-related attributes.
      */
     calculateSpeedAttributes() {
-        const objectStrains = this.objects.map((v) => v.tapStrain);
+        const objectStrains = this.objects.map((v) => v.speedStrain);
         const maxStrain = Math.max(...objectStrains);
         if (maxStrain) {
             this.attributes.speedNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
@@ -3394,7 +3472,6 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
      * The flashlight performance value.
      */
     flashlight = 0;
-    difficultyAttributes;
     finalMultiplier = 1.14;
     mode = osuBase.Modes.osu;
     calculateValues() {
@@ -3409,13 +3486,6 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             Math.pow(this.accuracy, 1.1) +
             Math.pow(this.flashlight, 1.1), 1 / 1.1) * this.finalMultiplier);
     }
-    /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
-     */
-    constructor(difficultyAttributes) {
-        super();
-        this.difficultyAttributes = osuBase.Utils.deepCopy(difficultyAttributes);
-    }
     /**
      * Calculates the aim performance value of the beatmap.
      */
@@ -3609,6 +3679,7 @@ exports.DifficultyHitObjectCreator = DifficultyHitObjectCreator;
 exports.DroidAim = DroidAim;
 exports.DroidAimEvaluator = DroidAimEvaluator;
 exports.DroidDifficultyCalculator = DroidDifficultyCalculator;
+exports.DroidDifficultyHitObject = DroidDifficultyHitObject;
 exports.DroidFlashlight = DroidFlashlight;
 exports.DroidFlashlightEvaluator = DroidFlashlightEvaluator;
 exports.DroidPerformanceCalculator = DroidPerformanceCalculator;
@@ -3623,6 +3694,7 @@ exports.MapStars = MapStars;
 exports.OsuAim = OsuAim;
 exports.OsuAimEvaluator = OsuAimEvaluator;
 exports.OsuDifficultyCalculator = OsuDifficultyCalculator;
+exports.OsuDifficultyHitObject = OsuDifficultyHitObject;
 exports.OsuFlashlight = OsuFlashlight;
 exports.OsuFlashlightEvaluator = OsuFlashlightEvaluator;
 exports.OsuPerformanceCalculator = OsuPerformanceCalculator;