@rian8337/osu-difficulty-calculator 4.0.0-beta.25 → 4.0.0-beta.27

package/dist/index.js

@@ -32,6 +32,12 @@ AimEvaluator.velocityChangeMultiplier = 0.75;
  * The base of a difficulty calculator.
  */
 class DifficultyCalculator {
+    /**
+     * The difficulty objects of the beatmap.
+     */
+    get objects() {
+        return this._objects;
+    }
     /**
      * The total star rating of the beatmap.
      */
@@ -41,13 +47,13 @@ class DifficultyCalculator {
     /**
      * Constructs a new instance of the calculator.
      *
-     * @param beatmap The beatmap to calculate. This beatmap will be deep-cloned to prevent reference changes.
+     * @param beatmap The beatmap to calculate.
      */
     constructor(beatmap) {
         /**
          * The difficulty objects of the beatmap.
          */
-        this.objects = [];
+        this._objects = [];
         /**
          * The modifications applied.
          */
@@ -62,13 +68,6 @@ class DifficultyCalculator {
             flashlight: [],
         };
         this.beatmap = beatmap;
-        this.difficultyStatistics = {
-            circleSize: beatmap.difficulty.cs,
-            approachRate: beatmap.difficulty.ar,
-            overallDifficulty: beatmap.difficulty.od,
-            healthDrain: beatmap.difficulty.hp,
-            overallSpeedMultiplier: 1,
-        };
     }
     /**
      * Calculates the star rating of the specified beatmap.
@@ -93,9 +92,9 @@ class DifficultyCalculator {
             mods: this.mods,
             customSpeedMultiplier: options === null || options === void 0 ? void 0 : options.customSpeedMultiplier,
         });
-        this.difficultyStatistics = Object.seal(this.computeDifficultyStatistics(options));
-        this.populateDifficultyAttributes();
-        this.objects.push(...this.generateDifficultyHitObjects(playableBeatmap));
+        const clockRate = this.calculateClockRate(options);
+        this.populateDifficultyAttributes(playableBeatmap, clockRate);
+        this._objects = this.generateDifficultyHitObjects(playableBeatmap, clockRate);
         this.calculateAll();
         return this;
     }
@@ -112,20 +111,40 @@ class DifficultyCalculator {
             }
         }
     }
+    /**
+     * Obtains the clock rate of the beatmap.
+     *
+     * @param options The options to obtain the clock rate with.
+     * @returns The clock rate of the beatmap.
+     */
+    calculateClockRate(options) {
+        var _a, _b;
+        return (osuBase.ModUtil.calculateRateWithMods((_a = options === null || options === void 0 ? void 0 : options.mods) !== null && _a !== void 0 ? _a : []) *
+            ((_b = options === null || options === void 0 ? void 0 : options.customSpeedMultiplier) !== null && _b !== void 0 ? _b : 1));
+    }
     /**
      * Populates the stored difficulty attributes with necessary data.
+     *
+     * @param beatmap The beatmap to populate the attributes with.
+     * @param clockRate The clock rate of the beatmap.
      */
-    populateDifficultyAttributes() {
-        this.attributes.approachRate = this.difficultyStatistics.approachRate;
+    populateDifficultyAttributes(beatmap, clockRate) {
         this.attributes.hitCircleCount = this.beatmap.hitObjects.circles;
         this.attributes.maxCombo = this.beatmap.maxCombo;
         this.attributes.mods = this.mods.slice();
-        this.attributes.overallDifficulty =
-            this.difficultyStatistics.overallDifficulty;
         this.attributes.sliderCount = this.beatmap.hitObjects.sliders;
         this.attributes.spinnerCount = this.beatmap.hitObjects.spinners;
-        this.attributes.clockRate =
-            this.difficultyStatistics.overallSpeedMultiplier;
+        this.attributes.clockRate = clockRate;
+        let greatWindow;
+        switch (this.mode) {
+            case osuBase.Modes.droid:
+                greatWindow = new osuBase.DroidHitWindow(beatmap.difficulty.od).hitWindowFor300(this.mods.some((m) => m instanceof osuBase.ModPrecise));
+                break;
+            case osuBase.Modes.osu:
+                greatWindow = new osuBase.OsuHitWindow(beatmap.difficulty.od).hitWindowFor300();
+                break;
+        }
+        this.attributes.overallDifficulty = osuBase.OsuHitWindow.hitWindow300ToOD(greatWindow / clockRate);
     }
     /**
      * Calculates the star rating value of a difficulty.
@@ -1057,7 +1076,7 @@ class DroidFlashlight extends DroidSkill {
         this.reducedSectionCount = 0;
         this.reducedSectionBaseline = 1;
         this.starsPerDouble = 1.06;
-        this.skillMultiplier = 0.052;
+        this.skillMultiplier = 0.02;
         this.currentFlashlightStrain = 0;
         this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
         this.withSliders = withSliders;
@@ -1086,64 +1105,42 @@ class DroidFlashlight extends DroidSkill {
         }
     }
     difficultyValue() {
-        return Math.pow(this.strainPeaks.reduce((a, v) => a + v, 0) * this.starsPerDouble, 0.8);
+        return (this.strainPeaks.reduce((a, v) => a + v, 0) * this.starsPerDouble);
     }
 }
 
-/**
- * An evaluator for calculating rhythm skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-class RhythmEvaluator {
-}
-RhythmEvaluator.rhythmMultiplier = 0.75;
-RhythmEvaluator.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
-
 class Island {
-    constructor(firstDelta, epsilon) {
-        this.deltas = [];
-        if (epsilon === undefined) {
-            this.deltaDifferenceEpsilon = firstDelta;
-            return;
+    constructor(delta, deltaDifferenceEpsilon) {
+        this.delta = Number.MAX_SAFE_INTEGER;
+        this.deltaCount = 0;
+        if (deltaDifferenceEpsilon === undefined) {
+            this.deltaDifferenceEpsilon = delta;
+        }
+        else {
+            this.deltaDifferenceEpsilon = deltaDifferenceEpsilon;
+            this.addDelta(delta);
         }
-        this.deltaDifferenceEpsilon = epsilon;
-        this.addDelta(firstDelta);
     }
     addDelta(delta) {
-        // Convert to integer
-        delta = Math.trunc(delta);
-        const existingDelta = this.deltas.find((v) => Math.abs(v - delta) >= this.deltaDifferenceEpsilon);
-        this.deltas.push(existingDelta !== null && existingDelta !== void 0 ? existingDelta : delta);
-    }
-    get averageDelta() {
-        return this.deltas.length > 0
-            ? Math.max(this.deltas.reduce((a, b) => a + b) / this.deltas.length, DifficultyHitObject.minDeltaTime)
-            : 0;
+        if (this.delta === Number.MAX_SAFE_INTEGER) {
+            this.delta = Math.max(Math.trunc(delta), DifficultyHitObject.minDeltaTime);
+        }
+        ++this.deltaCount;
     }
     isSimilarPolarity(other) {
-        // Consider islands to be of similar polarity only if they're having the same
-        // average delta (we don't want to consider 3 singletaps similar to a triple)
-        return (Math.abs(this.averageDelta - other.averageDelta) <
-            this.deltaDifferenceEpsilon &&
-            this.deltas.length % 2 === other.deltas.length % 2);
+        // TODO: consider islands to be of similar polarity only if they're having the same average delta (we don't want to consider 3 singletaps similar to a triple)
+        // naively adding delta check here breaks _a lot_ of maps because of the flawed ratio calculation
+        return this.deltaCount % 2 == other.deltaCount % 2;
     }
     equals(other) {
-        if (this.deltas.length !== other.deltas.length) {
-            return false;
-        }
-        for (let i = 0; i < this.deltas.length; ++i) {
-            if (this.deltas[i] !== other.deltas[i]) {
-                return false;
-            }
-        }
-        return true;
+        return (Math.abs(this.delta - other.delta) < this.deltaDifferenceEpsilon &&
+            this.deltaCount === other.deltaCount);
     }
 }
 /**
  * An evaluator for calculating osu!droid Rhythm skill.
  */
-class DroidRhythmEvaluator extends RhythmEvaluator {
+class DroidRhythmEvaluator {
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
@@ -1151,9 +1148,7 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
      * @param current The current object.
      */
     static evaluateDifficultyOf(current) {
-        if (current.object instanceof osuBase.Spinner ||
-            // Exclude overlapping objects that can be tapped at once.
-            current.isOverlapping(false)) {
+        if (current.object instanceof osuBase.Spinner) {
             return 1;
         }
         const deltaDifferenceEpsilon = current.fullGreatWindow * 0.3;
@@ -1183,47 +1178,50 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
             ++rhythmStart;
         }
         for (let i = rhythmStart; i > 0; --i) {
-            // Scale note 0 to 1 from history to now.
-            let currentHistoricalDecay = (this.historyTimeMax -
-                (current.startTime - validPrevious[i - 1].startTime)) /
-                this.historyTimeMax;
-            // Either we're limited by time or limited by object count.
-            currentHistoricalDecay = Math.min(currentHistoricalDecay, (validPrevious.length - i) / validPrevious.length);
             const currentObject = validPrevious[i - 1];
             const prevObject = validPrevious[i];
             const lastObject = validPrevious[i + 1];
+            // Scale note 0 to 1 from history to now.
+            const timeDecay = (this.historyTimeMax -
+                (current.startTime - currentObject.startTime)) /
+                this.historyTimeMax;
+            const noteDecay = (validPrevious.length - i) / validPrevious.length;
+            // Either we're limited by time or limited by object count.
+            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 +
-                10 *
-                    Math.min(0.5, Math.pow(Math.sin(Math.PI /
-                        (Math.min(prevDelta, currentDelta) /
-                            Math.max(prevDelta, currentDelta))), 2));
-            const windowPenalty = osuBase.MathUtils.clamp((Math.abs(prevDelta - currentDelta) - deltaDifferenceEpsilon) /
-                deltaDifferenceEpsilon, 0, 1);
-            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 (Math.abs(prevDelta - currentDelta) <= deltaDifferenceEpsilon) {
-                    if (island.deltas.length < this.maxIslandSize) {
-                        // Island is still progressing.
-                        island.addDelta(currentDelta);
-                    }
+                if (Math.abs(prevDelta - currentDelta) < deltaDifferenceEpsilon) {
+                    // Island is still progressing, count size.
+                    island.addDelta(currentDelta);
                 }
                 else {
                     // BPM change is into slider, this is easy acc window.
                     if (currentObject.object instanceof osuBase.Slider) {
                         effectiveRatio /= 8;
                     }
-                    // BPM change was from a slider, this is typically easier than circle -> circle.
-                    // Unintentional side effect is that bursts with kicksliders at the ends might
-                    // have lower difficulty than bursts without sliders.
+                    // 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 /= 4;
+                        effectiveRatio *= 0.3;
                     }
                     // Repeated island polarity (2 -> 4, 3 -> 5).
                     if (island.isSimilarPolarity(previousIsland)) {
-                        effectiveRatio *= 0.3;
+                        effectiveRatio /= 2;
                     }
                     // 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.
@@ -1231,8 +1229,9 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
                         prevDelta > currentDelta + deltaDifferenceEpsilon) {
                         effectiveRatio /= 8;
                     }
-                    // Singletaps are easier to control.
-                    if (island.deltas.length === 1) {
+                    // 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;
@@ -1249,9 +1248,7 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
                         }
                         // Repeated island (ex: triplet -> triplet).
                         // Graph: https://www.desmos.com/calculator/pj7an56zwf
-                        effectiveRatio *= Math.min(1 / islandCount, Math.pow(1 / islandCount, 4 /
-                            (1 +
-                                Math.exp(10 - 0.165 * island.averageDelta))));
+                        effectiveRatio *= Math.min(3 / islandCount, Math.pow(1 / islandCount, 2.75 / (1 + Math.exp(14 - 0.24 * island.delta))));
                         break;
                     }
                     if (!islandFound) {
@@ -1269,28 +1266,35 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
                         // If we're speeding up, this stays as is and we keep counting island size.
                         firstDeltaSwitch = false;
                     }
-                    island = new Island(Math.trunc(currentDelta), deltaDifferenceEpsilon);
+                    island = new Island(currentDelta, deltaDifferenceEpsilon);
                 }
             }
-            else if (prevDelta > deltaDifferenceEpsilon + currentDelta) {
-                // We're speeding up.
+            else if (prevDelta > currentDelta + deltaDifferenceEpsilon) {
+                // We are speeding up.
                 // Begin counting island until we change speed again.
                 firstDeltaSwitch = true;
-                // Reduce ratio if we're starting after a slider.
+                // 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.3;
+                    effectiveRatio *= 0.6;
                 }
                 startRatio = effectiveRatio;
-                island = new Island(Math.trunc(currentDelta), deltaDifferenceEpsilon);
+                island = new Island(currentDelta, deltaDifferenceEpsilon);
             }
         }
-        return Math.sqrt(4 + rhythmComplexitySum * this.rhythmMultiplier) / 2;
+        return (Math.sqrt(4 + rhythmComplexitySum * this.rhythmOverallMultiplier) /
+            2);
     }
 }
-DroidRhythmEvaluator.rhythmMultiplier = 1.2;
-DroidRhythmEvaluator.historyTimeMax = 4000;
-DroidRhythmEvaluator.maxIslandSize = 7;
-DroidRhythmEvaluator.historyObjectsMax = 24;
+DroidRhythmEvaluator.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
+DroidRhythmEvaluator.historyObjectsMax = 32;
+DroidRhythmEvaluator.rhythmOverallMultiplier = 0.95;
+DroidRhythmEvaluator.rhythmRatioMultiplier = 12;
 
 /**
  * Represents the skill required to properly follow a beatmap's rhythm.
@@ -1492,9 +1496,8 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
      * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
      * @param clockRate The clock rate of the beatmap.
      * @param greatWindow The great window of the hitobject.
-     * @param isForceAR Whether force AR is enabled.
      */
-    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, greatWindow, isForceAR) {
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, greatWindow) {
         super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, greatWindow);
         /**
          * The tap strain generated by the hitobject.
@@ -1538,10 +1541,7 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
         this.radiusBuffThreshold = 70;
         this.mode = osuBase.Modes.droid;
         this.maximumSliderRadius = this.normalizedRadius * 2;
-        this.timePreempt = object.timePreempt;
-        if (!isForceAR) {
-            this.timePreempt /= clockRate;
-        }
+        this.timePreempt = object.timePreempt / clockRate;
     }
     computeProperties(clockRate, hitObjects) {
         super.computeProperties(clockRate, hitObjects);
@@ -1553,6 +1553,9 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
      * Keep in mind that "overlapping" in this case is overlapping to the point where both hitobjects
      * can be hit with just a single tap in osu!droid.
      *
+     * In the case of sliders, it is considered overlapping if all nested hitobjects can be hit with
+     * one aim motion.
+     *
      * @param considerDistance Whether to consider the distance between both hitobjects.
      * @returns Whether the hitobject is considered overlapping.
      */
@@ -1560,23 +1563,48 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
         if (this.object instanceof osuBase.Spinner) {
             return false;
         }
-        const previous = this.previous(0);
-        if (!previous || previous.object instanceof osuBase.Spinner) {
+        const prev = this.previous(0);
+        if (!prev || prev.object instanceof osuBase.Spinner) {
+            return false;
+        }
+        if (this.object.startTime !== prev.object.startTime) {
             return false;
         }
-        if (this.deltaTime >= 5) {
+        if (!considerDistance) {
+            return true;
+        }
+        const distanceThreshold = 2 * this.object.radius;
+        const startPosition = this.object.getStackedPosition(osuBase.Modes.droid);
+        const prevStartPosition = prev.object.getStackedPosition(osuBase.Modes.droid);
+        // We need to consider two cases:
+        //
+        // Case 1: Current object is a circle, or previous object is a circle.
+        // In this case, we only need to check if their positions are close enough to be tapped together.
+        //
+        // Case 2: Both objects are sliders.
+        // In this case, we need to check if all nested hitobjects can be hit together.
+        // To start with, check if the starting positions can be tapped together.
+        if (startPosition.getDistance(prevStartPosition) > distanceThreshold) {
             return false;
         }
-        if (considerDistance) {
-            const endPosition = this.object.getStackedPosition(osuBase.Modes.droid);
-            let distance = previous.object
-                .getStackedEndPosition(osuBase.Modes.droid)
-                .getDistance(endPosition);
-            if (previous.object instanceof osuBase.Slider &&
-                previous.object.lazyEndPosition) {
-                distance = Math.min(distance, previous.object.lazyEndPosition.getDistance(endPosition));
+        if (this.object instanceof osuBase.Circle || prev.object instanceof osuBase.Circle) {
+            return true;
+        }
+        // Check if all nested hitobjects can be hit together.
+        for (let i = 1; i < this.object.nestedHitObjects.length; ++i) {
+            const position = this.object.nestedHitObjects[i].getStackedPosition(osuBase.Modes.droid);
+            const prevPosition = prevStartPosition.add(prev.object.curvePositionAt(i / (this.object.nestedHitObjects.length - 1)));
+            if (position.getDistance(prevPosition) > distanceThreshold) {
+                return false;
+            }
+        }
+        // Do the same for the previous slider as well.
+        for (let i = 1; i < prev.object.nestedHitObjects.length; ++i) {
+            const prevPosition = prev.object.nestedHitObjects[i].getStackedPosition(osuBase.Modes.droid);
+            const position = startPosition.add(this.object.curvePositionAt(i / (prev.object.nestedHitObjects.length - 1)));
+            if (prevPosition.getDistance(position) > distanceThreshold) {
+                return false;
             }
-            return distance <= 2 * this.object.radius;
         }
         return true;
     }
@@ -1660,7 +1688,6 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             speedNoteCount: 0,
             sliderFactor: 0,
             clockRate: 1,
-            approachRate: 0,
             overallDifficulty: 0,
             hitCircleCount: 0,
             sliderCount: 0,
@@ -1710,30 +1737,11 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         return this.attributes.visualDifficulty;
     }
     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,
-            vibroFactor: this.attributes.vibroFactor,
-        };
+        return Object.assign(Object.assign({}, this.attributes), { mods: osuBase.ModUtil.modsToOsuString(this.attributes.mods) });
+    }
+    // Override to use DroidDifficultyCalculationOptions
+    calculate(options) {
+        return super.calculate(options);
     }
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
@@ -1842,31 +1850,19 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             this.visual.toFixed(2) +
             " visual)");
     }
-    generateDifficultyHitObjects(convertedBeatmap) {
+    generateDifficultyHitObjects(beatmap, clockRate) {
         var _a, _b;
         const difficultyObjects = [];
-        const { objects } = convertedBeatmap.hitObjects;
-        const difficultyAdjustMod = this.mods.find((m) => m instanceof osuBase.ModDifficultyAdjust);
-        const greatWindow = new osuBase.OsuHitWindow(this.difficultyStatistics.overallDifficulty).hitWindowFor300();
+        const { objects } = beatmap.hitObjects;
+        const isPrecise = this.mods.some((m) => m instanceof osuBase.ModPrecise);
+        const greatWindow = new osuBase.DroidHitWindow(beatmap.difficulty.od).hitWindowFor300(isPrecise) / clockRate;
         for (let i = 0; i < objects.length; ++i) {
-            const difficultyObject = new DroidDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, (_b = objects[i - 2]) !== null && _b !== void 0 ? _b : null, difficultyObjects, this.difficultyStatistics.overallSpeedMultiplier, greatWindow, (difficultyAdjustMod === null || difficultyAdjustMod === void 0 ? void 0 : difficultyAdjustMod.ar) !== undefined);
-            difficultyObject.computeProperties(this.difficultyStatistics.overallSpeedMultiplier, objects);
+            const difficultyObject = new DroidDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, (_b = objects[i - 2]) !== null && _b !== void 0 ? _b : null, difficultyObjects, clockRate, greatWindow);
+            difficultyObject.computeProperties(clockRate, objects);
             difficultyObjects.push(difficultyObject);
         }
         return difficultyObjects;
     }
-    computeDifficultyStatistics(options) {
-        const { difficulty } = this.beatmap;
-        return osuBase.calculateDroidDifficultyStatistics({
-            circleSize: difficulty.cs,
-            approachRate: difficulty.ar,
-            overallDifficulty: difficulty.od,
-            healthDrain: difficulty.hp,
-            mods: this.mods,
-            customSpeedMultiplier: options === null || options === void 0 ? void 0 : options.customSpeedMultiplier,
-            oldStatistics: options === null || options === void 0 ? void 0 : options.oldStatistics,
-        });
-    }
     createSkills() {
         return [
             new DroidAim(this.mods, true),
@@ -1883,6 +1879,10 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             new DroidVisual(this.mods, false),
         ];
     }
+    calculateClockRate(options) {
+        var _a, _b;
+        return (osuBase.ModUtil.calculateRateWithMods((_a = options === null || options === void 0 ? void 0 : options.mods) !== null && _a !== void 0 ? _a : [], options === null || options === void 0 ? void 0 : options.oldStatistics) * ((_b = options === null || options === void 0 ? void 0 : options.customSpeedMultiplier) !== null && _b !== void 0 ? _b : 1));
+    }
     /**
      * Called after aim skill calculation.
      *
@@ -3030,7 +3030,7 @@ OsuSpeedEvaluator.SINGLE_SPACING_THRESHOLD = 125;
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
  */
-class OsuRhythmEvaluator extends RhythmEvaluator {
+class OsuRhythmEvaluator {
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
@@ -3136,6 +3136,8 @@ class OsuRhythmEvaluator extends RhythmEvaluator {
         return Math.sqrt(4 + rhythmComplexitySum * this.rhythmMultiplier) / 2;
     }
 }
+OsuRhythmEvaluator.rhythmMultiplier = 0.75;
+OsuRhythmEvaluator.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
 
 /**
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
@@ -3447,29 +3449,19 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             this.flashlight.toFixed(2) +
             " flashlight)");
     }
-    generateDifficultyHitObjects(convertedBeatmap) {
+    generateDifficultyHitObjects(beatmap, clockRate) {
         var _a, _b;
         const difficultyObjects = [];
-        const { objects } = convertedBeatmap.hitObjects;
-        const greatWindow = new osuBase.OsuHitWindow(this.difficultyStatistics.overallDifficulty).hitWindowFor300();
+        const { objects } = beatmap.hitObjects;
+        const greatWindow = new osuBase.OsuHitWindow(beatmap.difficulty.od).hitWindowFor300() /
+            clockRate;
         for (let i = 0; i < objects.length; ++i) {
-            const difficultyObject = new OsuDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, (_b = objects[i - 2]) !== null && _b !== void 0 ? _b : null, difficultyObjects, this.difficultyStatistics.overallSpeedMultiplier, greatWindow);
-            difficultyObject.computeProperties(this.difficultyStatistics.overallSpeedMultiplier, objects);
+            const difficultyObject = new OsuDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, (_b = objects[i - 2]) !== null && _b !== void 0 ? _b : null, difficultyObjects, clockRate, greatWindow);
+            difficultyObject.computeProperties(clockRate, objects);
             difficultyObjects.push(difficultyObject);
         }
         return difficultyObjects;
     }
-    computeDifficultyStatistics(options) {
-        const { difficulty } = this.beatmap;
-        return osuBase.calculateOsuDifficultyStatistics({
-            circleSize: difficulty.cs,
-            approachRate: difficulty.ar,
-            overallDifficulty: difficulty.od,
-            healthDrain: difficulty.hp,
-            mods: options === null || options === void 0 ? void 0 : options.mods,
-            customSpeedMultiplier: options === null || options === void 0 ? void 0 : options.customSpeedMultiplier,
-        });
-    }
     createSkills() {
         return [
             new OsuAim(this.mods, true),
@@ -3478,6 +3470,11 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             new OsuFlashlight(this.mods),
         ];
     }
+    populateDifficultyAttributes(beatmap, clockRate) {
+        super.populateDifficultyAttributes(beatmap, clockRate);
+        const preempt = osuBase.BeatmapDifficulty.difficultyRange(beatmap.difficulty.ar, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin) / clockRate;
+        this.attributes.approachRate = osuBase.BeatmapDifficulty.inverseDifficultyRange(preempt, osuBase.HitObject.preemptMax, osuBase.HitObject.preemptMid, osuBase.HitObject.preemptMin);
+    }
     /**
      * Called after aim skill calculation.
      *
@@ -3784,6 +3781,5 @@ exports.OsuRhythmEvaluator = OsuRhythmEvaluator;
 exports.OsuSpeed = OsuSpeed;
 exports.OsuSpeedEvaluator = OsuSpeedEvaluator;
 exports.PerformanceCalculator = PerformanceCalculator;
-exports.RhythmEvaluator = RhythmEvaluator;
 exports.SpeedEvaluator = SpeedEvaluator;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.25",
+    "version": "4.0.0-beta.27",
     "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.25"
+        "@rian8337/osu-base": "^4.0.0-beta.27"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "2d6271ea24c787caad1d24c3d20dbeeaf450359e"
+    "gitHead": "6714ebe03b132a0f9406a72900af70a9c39a58bc"
 }

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-import { Mod, PlaceableHitObject, Modes, Beatmap, DifficultyStatisticsCalculatorResult, Accuracy } from '@rian8337/osu-base';
+import { Mod, PlaceableHitObject, Modes, Beatmap, Accuracy } from '@rian8337/osu-base';
 
 /**
  * An evaluator for calculating aim skill.
@@ -62,12 +62,6 @@ interface DifficultyAttributes {
      * The overall clock rate that was applied to the beatmap.
      */
     clockRate: number;
-    /**
-     * The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
-     *
-     * Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
-     */
-    approachRate: number;
     /**
      * The perceived overall difficulty inclusive of rate-adjusting mods (DT/HT/etc), based on osu!standard judgement.
      *
@@ -327,7 +321,11 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
     /**
      * The difficulty objects of the beatmap.
      */
-    readonly objects: THitObject[];
+    private _objects;
+    /**
+     * The difficulty objects of the beatmap.
+     */
+    get objects(): readonly THitObject[];
     /**
      * The modifications applied.
      */
@@ -336,10 +334,6 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
      * The total star rating of the beatmap.
      */
     get total(): number;
-    /**
-     * The difficulty statistics of the beatmap after modifications are applied.
-     */
-    difficultyStatistics: DifficultyStatisticsCalculatorResult<number, number, number, number>;
     /**
      * The strain peaks of various calculated difficulties.
      */
@@ -357,7 +351,7 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
     /**
      * Constructs a new instance of the calculator.
      *
-     * @param beatmap The beatmap to calculate. This beatmap will be deep-cloned to prevent reference changes.
+     * @param beatmap The beatmap to calculate.
      */
     constructor(beatmap: Beatmap);
     /**
@@ -379,16 +373,10 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
     /**
      * Generates difficulty hitobjects for this calculator.
      *
-     * @param convertedBeatmap The beatmap to generate difficulty hitobjects from.
-     */
-    protected abstract generateDifficultyHitObjects(convertedBeatmap: Beatmap): THitObject[];
-    /**
-     * Computes the difficulty statistics of the original beatmap with respect to the used options.
-     *
-     * @param options The options to use for the difficulty statistics calculation.
-     * @returns The computed difficulty statistics.
+     * @param beatmap The beatmap to generate difficulty hitobjects from.
+     * @param clockRate The clock rate of the beatmap.
      */
-    protected abstract computeDifficultyStatistics(options?: DifficultyCalculationOptions): DifficultyStatisticsCalculatorResult<number, number, number, number>;
+    protected abstract generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): THitObject[];
     /**
      * Calculates the skills provided.
      *
@@ -411,10 +399,20 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
      * Creates skills to be calculated.
      */
     protected abstract createSkills(): Skill[];
+    /**
+     * Obtains the clock rate of the beatmap.
+     *
+     * @param options The options to obtain the clock rate with.
+     * @returns The clock rate of the beatmap.
+     */
+    protected calculateClockRate(options?: DifficultyCalculationOptions): number;
     /**
      * Populates the stored difficulty attributes with necessary data.
+     *
+     * @param beatmap The beatmap to populate the attributes with.
+     * @param clockRate The clock rate of the beatmap.
      */
-    protected populateDifficultyAttributes(): void;
+    protected populateDifficultyAttributes(beatmap: Beatmap, clockRate: number): void;
     /**
      * Calculates the star rating value of a difficulty.
      *
@@ -616,9 +614,8 @@ declare class DroidDifficultyHitObject extends DifficultyHitObject {
      * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
      * @param clockRate The clock rate of the beatmap.
      * @param greatWindow The great window of the hitobject.
-     * @param isForceAR Whether force AR is enabled.
      */
-    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, greatWindow: number, isForceAR: boolean);
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, greatWindow: number);
     computeProperties(clockRate: number, hitObjects: readonly PlaceableHitObject[]): void;
     /**
      * Determines whether this hitobject is considered overlapping with the hitobject before it.
@@ -626,6 +623,9 @@ declare class DroidDifficultyHitObject extends DifficultyHitObject {
      * Keep in mind that "overlapping" in this case is overlapping to the point where both hitobjects
      * can be hit with just a single tap in osu!droid.
      *
+     * In the case of sliders, it is considered overlapping if all nested hitobjects can be hit with
+     * one aim motion.
+     *
      * @param considerDistance Whether to consider the distance between both hitobjects.
      * @returns Whether the hitobject is considered overlapping.
      */
@@ -835,6 +835,7 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidDiffic
     get cacheableAttributes(): CacheableDifficultyAttributes<DroidDifficultyAttributes>;
     protected readonly difficultyMultiplier = 0.18;
     protected readonly mode = Modes.droid;
+    calculate(options?: DroidDifficultyCalculationOptions): this;
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -858,9 +859,9 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidDiffic
     calculateTotal(): void;
     calculateAll(): void;
     toString(): string;
-    protected generateDifficultyHitObjects(convertedBeatmap: Beatmap): DroidDifficultyHitObject[];
-    protected computeDifficultyStatistics(options?: DroidDifficultyCalculationOptions): DifficultyStatisticsCalculatorResult<number, number, number, number>;
+    protected generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): DroidDifficultyHitObject[];
     protected createSkills(): DroidSkill[];
+    protected calculateClockRate(options?: DroidDifficultyCalculationOptions): number;
     /**
      * Called after aim skill calculation.
      *
@@ -1266,24 +1267,14 @@ declare class DroidRhythm extends DroidSkill {
     protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
-/**
- * An evaluator for calculating rhythm skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-declare abstract class RhythmEvaluator {
-    protected static readonly rhythmMultiplier: number;
-    protected static readonly historyTimeMax: number;
-}
-
 /**
  * An evaluator for calculating osu!droid Rhythm skill.
  */
-declare abstract class DroidRhythmEvaluator extends RhythmEvaluator {
-    protected static readonly rhythmMultiplier = 1.2;
-    protected static readonly historyTimeMax = 4000;
-    private static readonly maxIslandSize;
+declare abstract class DroidRhythmEvaluator {
+    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.
@@ -1481,6 +1472,12 @@ declare abstract class OsuAimEvaluator extends AimEvaluator {
  * Holds data that can be used to calculate osu!standard performance points.
  */
 interface OsuDifficultyAttributes extends DifficultyAttributes {
+    /**
+     * The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
+     *
+     * Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
+     */
+    approachRate: number;
     /**
      * The difficulty corresponding to the speed skill.
      */
@@ -1522,9 +1519,9 @@ declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuDifficulty
     calculateTotal(): void;
     calculateAll(): void;
     toString(): string;
-    protected generateDifficultyHitObjects(convertedBeatmap: Beatmap): OsuDifficultyHitObject[];
-    protected computeDifficultyStatistics(options?: DifficultyCalculationOptions): DifficultyStatisticsCalculatorResult<number, number, number, number>;
+    protected generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): OsuDifficultyHitObject[];
     protected createSkills(): OsuSkill[];
+    protected populateDifficultyAttributes(beatmap: Beatmap, clockRate: number): void;
     /**
      * Called after aim skill calculation.
      *
@@ -1632,7 +1629,9 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<OsuDifficul
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
  */
-declare abstract class OsuRhythmEvaluator extends RhythmEvaluator {
+declare abstract class OsuRhythmEvaluator {
+    private static readonly rhythmMultiplier;
+    private static readonly historyTimeMax;
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
@@ -1686,4 +1685,4 @@ declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
     static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
 }
 
-export { AimEvaluator, type CacheableDifficultyAttributes, type DifficultSlider, type DifficultyAttributes, type DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DroidAim, DroidAimEvaluator, type DroidDifficultyAttributes, type DroidDifficultyCalculationOptions, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, type ExtendedDroidDifficultyAttributes, FlashlightEvaluator, type HighStrainSection, OsuAim, OsuAimEvaluator, type OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, RhythmEvaluator, SpeedEvaluator, type StrainPeaks };
+export { AimEvaluator, type CacheableDifficultyAttributes, type DifficultSlider, type DifficultyAttributes, type DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DroidAim, DroidAimEvaluator, type DroidDifficultyAttributes, type DroidDifficultyCalculationOptions, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, type ExtendedDroidDifficultyAttributes, FlashlightEvaluator, type HighStrainSection, OsuAim, OsuAimEvaluator, type OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, SpeedEvaluator, type StrainPeaks };