@rian8337/osu-difficulty-calculator 4.0.0-beta.24 → 4.0.0-beta.26

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,14 +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) {
-        var _a;
         /**
          * The difficulty objects of the beatmap.
          */
-        this.objects = [];
+        this._objects = [];
         /**
          * The modifications applied.
          */
@@ -63,13 +68,6 @@ class DifficultyCalculator {
             flashlight: [],
         };
         this.beatmap = beatmap;
-        this.difficultyStatistics = {
-            circleSize: beatmap.difficulty.cs,
-            approachRate: (_a = beatmap.difficulty.ar) !== null && _a !== void 0 ? _a : beatmap.difficulty.od,
-            overallDifficulty: beatmap.difficulty.od,
-            healthDrain: beatmap.difficulty.hp,
-            overallSpeedMultiplier: 1,
-        };
     }
     /**
      * Calculates the star rating of the specified beatmap.
@@ -87,16 +85,17 @@ class DifficultyCalculator {
      * @returns The current instance.
      */
     calculate(options) {
-        var _a;
+        var _a, _b;
         this.mods = (_a = options === null || options === void 0 ? void 0 : options.mods) !== null && _a !== void 0 ? _a : [];
-        const converted = new osuBase.BeatmapConverter(this.beatmap).convert({
+        const playableBeatmap = this.beatmap.createPlayableBeatmap({
             mode: this.mode,
             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(converted));
+        const clockRate = osuBase.ModUtil.calculateRateWithMods(this.mods) *
+            ((_b = options === null || options === void 0 ? void 0 : options.customSpeedMultiplier) !== null && _b !== void 0 ? _b : 1);
+        this.populateDifficultyAttributes(playableBeatmap, clockRate);
+        this._objects = this.generateDifficultyHitObjects(playableBeatmap, clockRate);
         this.calculateAll();
         return this;
     }
@@ -115,18 +114,27 @@ class DifficultyCalculator {
     }
     /**
      * 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.
@@ -159,8 +167,9 @@ class DifficultyHitObject {
      * @param lastLastObject The hitobject before the last hitobject.
      * @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.
      */
-    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate) {
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, greatWindow) {
         /**
          * The aim strain generated by the hitobject if sliders are considered.
          */
@@ -213,18 +222,18 @@ class DifficultyHitObject {
         this.normalizedRadius = 50;
         this.maximumSliderRadius = this.normalizedRadius * 2.4;
         this.assumedSliderRadius = this.normalizedRadius * 1.8;
-        this.minDeltaTime = 25;
         this.object = object;
         this.lastObject = lastObject;
         this.lastLastObject = lastLastObject;
         this.hitObjects = difficultyHitObjects;
+        this.fullGreatWindow = greatWindow * 2;
         this.index = difficultyHitObjects.length - 1;
         // Capped to 25ms to prevent difficulty calculation breaking from simultaneous objects.
         this.startTime = object.startTime / clockRate;
         this.endTime = object.endTime / clockRate;
         if (lastObject) {
             this.deltaTime = this.startTime - lastObject.startTime / clockRate;
-            this.strainTime = Math.max(this.deltaTime, this.minDeltaTime);
+            this.strainTime = Math.max(this.deltaTime, DifficultyHitObject.minDeltaTime);
         }
         else {
             this.deltaTime = 0;
@@ -295,6 +304,24 @@ class DifficultyHitObject {
         }
         return osuBase.MathUtils.clamp((time - fadeInStartTime) / fadeInDuration, 0, 1);
     }
+    /**
+     * How possible is it to doubletap this object together with the next one and get perfect
+     * judgement in range from 0 to 1.
+     *
+     * A value closer to 1 indicates a higher possibility.
+     */
+    get doubletapness() {
+        const next = this.next(0);
+        if (!next) {
+            return 0;
+        }
+        const currentDeltaTime = Math.max(1, this.deltaTime);
+        const nextDeltaTime = Math.max(1, next.deltaTime);
+        const deltaDifference = Math.abs(nextDeltaTime - currentDeltaTime);
+        const speedRatio = currentDeltaTime / Math.max(currentDeltaTime, deltaDifference);
+        const windowRatio = Math.pow(Math.min(1, currentDeltaTime / this.fullGreatWindow), 2);
+        return 1 - Math.pow(speedRatio, 1 - windowRatio);
+    }
     setDistances(clockRate) {
         if (this.object instanceof osuBase.Slider) {
             this.calculateSliderCursorPosition(this.object);
@@ -306,7 +333,7 @@ class DifficultyHitObject {
             else {
                 this.travelDistance *= Math.pow(1 + this.object.repeatCount / 2.5, 1 / 2.5);
             }
-            this.travelTime = Math.max(this.object.lazyTravelTime / clockRate, this.minDeltaTime);
+            this.travelTime = Math.max(this.object.lazyTravelTime / clockRate, DifficultyHitObject.minDeltaTime);
         }
         // We don't need to calculate either angle or distance when one of the last->curr objects is a spinner.
         if (!this.lastObject ||
@@ -324,8 +351,8 @@ class DifficultyHitObject {
         this.minimumJumpTime = this.strainTime;
         this.minimumJumpDistance = this.lazyJumpDistance;
         if (this.lastObject instanceof osuBase.Slider) {
-            const lastTravelTime = Math.max(this.lastObject.lazyTravelTime / clockRate, this.minDeltaTime);
-            this.minimumJumpTime = Math.max(this.strainTime - lastTravelTime, this.minDeltaTime);
+            const lastTravelTime = Math.max(this.lastObject.lazyTravelTime / clockRate, DifficultyHitObject.minDeltaTime);
+            this.minimumJumpTime = Math.max(this.strainTime - lastTravelTime, DifficultyHitObject.minDeltaTime);
             // There are two types of slider-to-object patterns to consider in order to better approximate the real movement a player will take to jump between the hitobjects.
             //
             // 1. The anti-flow pattern, where players cut the slider short in order to move to the next hitobject.
@@ -440,6 +467,10 @@ class DifficultyHitObject {
         return pos;
     }
 }
+/**
+ * The lowest possible delta time value.
+ */
+DifficultyHitObject.minDeltaTime = 25;
 
 /**
  * An evaluator for calculating osu!droid Aim skill.
@@ -692,6 +723,7 @@ class DroidSkill extends StrainSkill {
     constructor() {
         super(...arguments);
         this._objectStrains = [];
+        this.difficulty = 0;
     }
     /**
      * The strains of hitobjects.
@@ -705,14 +737,14 @@ class DroidSkill extends StrainSkill {
      * The result is scaled by clock rate as it affects the total number of strains.
      */
     countDifficultStrains() {
-        if (this._objectStrains.length === 0) {
+        if (this.difficulty === 0) {
             return 0;
         }
-        const maxStrain = Math.max(...this._objectStrains);
-        if (maxStrain === 0) {
-            return 0;
-        }
-        return this._objectStrains.reduce((total, next) => total + Math.pow(next / maxStrain, 4), 0);
+        // This is what the top strain is if all strain values were identical.
+        const consistentTopStrain = this.difficulty / 10;
+        // Use a weighted sum of all strains.
+        return this._objectStrains.reduce((total, next) => total +
+            1.1 / (1 + Math.exp(-10 * (next / consistentTopStrain - 0.88))), 0);
     }
     process(current) {
         super.process(current);
@@ -730,12 +762,12 @@ class DroidSkill extends StrainSkill {
         }
         // Math here preserves the property that two notes of equal difficulty x, we have their summed difficulty = x * starsPerDouble.
         // This also applies to two sets of notes with equal difficulty.
-        return Math.pow(strains.reduce((a, v) => {
-            if (v <= 0) {
-                return a;
-            }
-            return a + Math.pow(v, 1 / Math.log2(this.starsPerDouble));
-        }, 0), Math.log2(this.starsPerDouble));
+        this.difficulty = 0;
+        for (const strain of strains) {
+            this.difficulty += Math.pow(strain, 1 / Math.log2(this.starsPerDouble));
+        }
+        this.difficulty = Math.pow(this.difficulty, Math.log2(this.starsPerDouble));
+        return this.difficulty;
     }
     calculateCurrentSectionStart(current) {
         return current.startTime;
@@ -811,27 +843,16 @@ class DroidTapEvaluator extends SpeedEvaluator {
      * @param considerCheesability Whether to consider cheesability.
      * @param strainTimeCap The strain time to cap the object's strain time to.
      */
-    static evaluateDifficultyOf(current, greatWindow, considerCheesability, strainTimeCap) {
+    static evaluateDifficultyOf(current, considerCheesability, strainTimeCap) {
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
             current.isOverlapping(false)) {
             return 0;
         }
-        let doubletapness = 1;
-        if (considerCheesability) {
-            // Nerf doubletappable doubles.
-            const next = current.next(0);
-            if (next) {
-                const greatWindowFull = greatWindow * 2;
-                const currentDeltaTime = Math.max(1, current.deltaTime);
-                const nextDeltaTime = Math.max(1, next.deltaTime);
-                const deltaDifference = Math.abs(nextDeltaTime - currentDeltaTime);
-                const speedRatio = currentDeltaTime /
-                    Math.max(currentDeltaTime, deltaDifference);
-                const windowRatio = Math.pow(Math.min(1, currentDeltaTime / greatWindowFull), 2);
-                doubletapness = Math.pow(speedRatio, 1 - windowRatio);
-            }
-        }
+        // Nerf doubletappable doubles.
+        const doubletapness = considerCheesability
+            ? 1 - current.doubletapness
+            : 1;
         const strainTime = strainTimeCap !== undefined
             ? // We cap the strain time to 50 here as the chance of vibro is higher in any BPM higher than 300.
                 Math.max(50, strainTimeCap, current.strainTime)
@@ -856,7 +877,7 @@ class DroidTap extends DroidSkill {
     get objectDeltaTimes() {
         return this._objectDeltaTimes;
     }
-    constructor(mods, overallDifficulty, considerCheesability, strainTimeCap) {
+    constructor(mods, considerCheesability, strainTimeCap) {
         super(mods);
         this.reducedSectionCount = 10;
         this.reducedSectionBaseline = 0.75;
@@ -866,7 +887,6 @@ class DroidTap extends DroidSkill {
         this.currentRhythmMultiplier = 0;
         this.skillMultiplier = 1375;
         this._objectDeltaTimes = [];
-        this.greatWindow = new osuBase.OsuHitWindow(overallDifficulty).hitWindowFor300();
         this.considerCheesability = considerCheesability;
         this.strainTimeCap = strainTimeCap;
     }
@@ -905,7 +925,7 @@ class DroidTap extends DroidSkill {
     strainValueAt(current) {
         this.currentTapStrain *= this.strainDecay(current.strainTime);
         this.currentTapStrain +=
-            DroidTapEvaluator.evaluateDifficultyOf(current, this.greatWindow, this.considerCheesability, this.strainTimeCap) * this.skillMultiplier;
+            DroidTapEvaluator.evaluateDifficultyOf(current, this.considerCheesability, this.strainTimeCap) * this.skillMultiplier;
         this.currentRhythmMultiplier = current.rhythmMultiplier;
         this._objectDeltaTimes.push(current.deltaTime);
         return this.currentTapStrain * current.rhythmMultiplier;
@@ -1046,7 +1066,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;
@@ -1075,45 +1095,62 @@ 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 {
+class Island {
+    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);
+        }
+    }
+    addDelta(delta) {
+        if (this.delta === Number.MAX_SAFE_INTEGER) {
+            this.delta = Math.max(Math.trunc(delta), DifficultyHitObject.minDeltaTime);
+        }
+        ++this.deltaCount;
+    }
+    isSimilarPolarity(other) {
+        // 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) {
+        return (Math.abs(this.delta - other.delta) < this.deltaDifferenceEpsilon &&
+            this.deltaCount === other.deltaCount);
+    }
 }
-RhythmEvaluator.rhythmMultiplier = 0.75;
-RhythmEvaluator.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
-
 /**
  * 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.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current, greatWindow) {
-        if (current.object instanceof osuBase.Spinner ||
-            // Exclude overlapping objects that can be tapped at once.
-            current.isOverlapping(false)) {
+    static evaluateDifficultyOf(current) {
+        if (current.object instanceof osuBase.Spinner) {
             return 1;
         }
-        let previousIslandSize = 0;
+        const deltaDifferenceEpsilon = current.fullGreatWindow * 0.3;
         let rhythmComplexitySum = 0;
-        let islandSize = 1;
+        let island = new Island(deltaDifferenceEpsilon);
+        let previousIsland = new Island(deltaDifferenceEpsilon);
+        const islandCounts = new Map();
         // Store the ratio of the current start of an island to buff for tighter rhythms.
         let startRatio = 0;
         let firstDeltaSwitch = false;
         let rhythmStart = 0;
-        const historicalNoteCount = Math.min(current.index, 32);
+        const historicalNoteCount = Math.min(current.index, this.historyObjectsMax);
         // Exclude overlapping objects that can be tapped at once.
         const validPrevious = [];
         for (let i = 0; i < historicalNoteCount; ++i) {
@@ -1131,111 +1168,140 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
             ++rhythmStart;
         }
         for (let i = rhythmStart; i > 0; --i) {
+            const currentObject = validPrevious[i - 1];
+            const prevObject = validPrevious[i];
+            const lastObject = validPrevious[i + 1];
             // Scale note 0 to 1 from history to now.
-            let currentHistoricalDecay = (this.historyTimeMax -
-                (current.startTime - validPrevious[i - 1].startTime)) /
+            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.
-            currentHistoricalDecay = Math.min(currentHistoricalDecay, (validPrevious.length - i) / validPrevious.length);
-            const currentDelta = validPrevious[i - 1].strainTime;
-            const prevDelta = validPrevious[i].strainTime;
-            const lastDelta = validPrevious[i + 1].strainTime;
+            const currentHistoricalDecay = Math.min(timeDecay, noteDecay);
+            const currentDelta = currentObject.strainTime;
+            const prevDelta = prevObject.strainTime;
+            const lastDelta = lastObject.strainTime;
+            // Calculate how much current delta difference deserves a rhythm bonus
+            // This function is meant to reduce rhythm bonus for deltas that are multiples of each other (i.e. 100 and 200)
+            const deltaDifferenceRatio = Math.min(prevDelta, currentDelta) /
+                Math.max(prevDelta, currentDelta);
             const currentRatio = 1 +
-                6 *
-                    Math.min(0.5, Math.pow(Math.sin(Math.PI /
-                        (Math.min(prevDelta, currentDelta) /
-                            Math.max(prevDelta, currentDelta))), 2));
-            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - greatWindow * 0.6) /
-                (greatWindow * 0.6));
-            let effectiveRatio = windowPenalty * currentRatio;
+                this.rhythmRatioMultiplier *
+                    Math.min(0.5, Math.pow(Math.sin(Math.PI / deltaDifferenceRatio), 2));
+            // Reduce ratio bonus if delta difference is too big
+            const fraction = Math.max(prevDelta / currentDelta, currentDelta / prevDelta);
+            const fractionMultiplier = osuBase.MathUtils.clamp(2 - fraction / 8, 0, 1);
+            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - deltaDifferenceEpsilon) / deltaDifferenceEpsilon);
+            let effectiveRatio = windowPenalty * currentRatio * fractionMultiplier;
             if (firstDeltaSwitch) {
-                if (prevDelta <= 1.25 * currentDelta &&
-                    prevDelta * 1.25 >= currentDelta) {
+                if (Math.abs(prevDelta - currentDelta) < deltaDifferenceEpsilon) {
                     // Island is still progressing, count size.
-                    if (islandSize < 7) {
-                        ++islandSize;
-                    }
+                    island.addDelta(currentDelta);
                 }
                 else {
-                    if (validPrevious[i - 1].object instanceof osuBase.Slider) {
-                        // BPM change is into slider, this is easy acc window.
+                    // BPM change is into slider, this is easy acc window.
+                    if (currentObject.object instanceof osuBase.Slider) {
                         effectiveRatio /= 8;
                     }
-                    if (validPrevious[i].object instanceof osuBase.Slider) {
-                        // BPM change was from a slider, this is typically easier than circle -> circle.
-                        effectiveRatio /= 4;
-                    }
-                    if (previousIslandSize === islandSize) {
-                        // Repeated island size (ex: triplet -> triplet).
-                        effectiveRatio /= 4;
+                    // 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;
                     }
-                    if (previousIslandSize % 2 === islandSize % 2) {
-                        // Repeated island polarity (2 -> 4, 3 -> 5).
+                    // Repeated island polarity (2 -> 4, 3 -> 5).
+                    if (island.isSimilarPolarity(previousIsland)) {
                         effectiveRatio /= 2;
                     }
-                    if (lastDelta > prevDelta + 10 &&
-                        prevDelta > currentDelta + 10) {
-                        // Previous increase happened a note ago.
-                        // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                    // Previous increase happened a note ago.
+                    // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                    if (lastDelta > prevDelta + deltaDifferenceEpsilon &&
+                        prevDelta > currentDelta + deltaDifferenceEpsilon) {
                         effectiveRatio /= 8;
                     }
+                    // Repeated island size (ex: triplet -> triplet).
+                    // TODO: remove this nerf since its staying here only for balancing purposes because of the flawed ratio calculation
+                    if (previousIsland.deltaCount == island.deltaCount) {
+                        effectiveRatio /= 2;
+                    }
+                    let islandFound = false;
+                    for (const [currentIsland, count] of islandCounts) {
+                        if (!island.equals(currentIsland)) {
+                            continue;
+                        }
+                        islandFound = true;
+                        let islandCount = count;
+                        if (previousIsland.equals(island)) {
+                            // Only add island to island counts if they're going one after another.
+                            ++islandCount;
+                            islandCounts.set(currentIsland, islandCount);
+                        }
+                        // Repeated island (ex: triplet -> triplet).
+                        // Graph: https://www.desmos.com/calculator/pj7an56zwf
+                        effectiveRatio *= Math.min(3 / islandCount, Math.pow(1 / islandCount, 2.75 / (1 + Math.exp(14 - 0.24 * island.delta))));
+                        break;
+                    }
+                    if (!islandFound) {
+                        islandCounts.set(island, 1);
+                    }
+                    // Scale down the difficulty if the object is doubletappable.
+                    effectiveRatio *= 1 - prevObject.doubletapness * 0.75;
                     rhythmComplexitySum +=
-                        (((Math.sqrt(effectiveRatio * startRatio) *
-                            currentHistoricalDecay *
-                            Math.sqrt(4 + islandSize)) /
-                            2) *
-                            Math.sqrt(4 + previousIslandSize)) /
-                            2;
+                        Math.sqrt(effectiveRatio * startRatio) *
+                            currentHistoricalDecay;
                     startRatio = effectiveRatio;
-                    previousIslandSize = islandSize;
-                    if (prevDelta * 1.25 < currentDelta) {
+                    previousIsland = island;
+                    if (prevDelta + deltaDifferenceEpsilon < currentDelta) {
                         // We're slowing down, stop counting.
                         // If we're speeding up, this stays as is and we keep counting island size.
                         firstDeltaSwitch = false;
                     }
-                    islandSize = 1;
+                    island = new Island(currentDelta, deltaDifferenceEpsilon);
                 }
             }
-            else if (prevDelta > 1.25 * currentDelta) {
-                // We want to be speeding up.
+            else if (prevDelta > currentDelta + deltaDifferenceEpsilon) {
+                // We are speeding up.
                 // Begin counting island until we change speed again.
                 firstDeltaSwitch = true;
+                // BPM change is into slider, this is easy acc window.
+                if (currentObject.object instanceof osuBase.Slider) {
+                    effectiveRatio *= 0.6;
+                }
+                // BPM change was from a slider, this is easier typically than circle -> circle
+                // Unintentional side effect is that bursts with kicksliders at the ends might have lower difficulty
+                // than bursts without sliders
+                if (prevObject.object instanceof osuBase.Slider) {
+                    effectiveRatio *= 0.6;
+                }
                 startRatio = effectiveRatio;
-                islandSize = 1;
+                island = new Island(currentDelta, deltaDifferenceEpsilon);
             }
         }
-        // Nerf doubles that can be tapped at the same time to get Great hit results.
-        const next = current.next(0);
-        let doubletapness = 1;
-        if (next) {
-            const currentDeltaTime = Math.max(1, current.deltaTime);
-            const nextDeltaTime = Math.max(1, next.deltaTime);
-            const deltaDifference = Math.abs(nextDeltaTime - currentDeltaTime);
-            const speedRatio = currentDeltaTime / Math.max(currentDeltaTime, deltaDifference);
-            const windowRatio = Math.pow(Math.min(1, currentDeltaTime / (greatWindow * 2)), 2);
-            doubletapness = Math.pow(speedRatio, 1 - windowRatio);
-        }
-        return (Math.sqrt(4 + rhythmComplexitySum * this.rhythmMultiplier * doubletapness) / 2);
+        return (Math.sqrt(4 + rhythmComplexitySum * this.rhythmOverallMultiplier) /
+            2);
     }
 }
+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.
  */
 class DroidRhythm extends DroidSkill {
-    constructor(mods, overallDifficulty) {
-        super(mods);
+    constructor() {
+        super(...arguments);
         this.reducedSectionCount = 5;
         this.reducedSectionBaseline = 0.75;
         this.strainDecayBase = 0.3;
         this.starsPerDouble = 1.75;
         this.currentRhythmStrain = 0;
         this.currentRhythmMultiplier = 1;
-        this.hitWindow = new osuBase.OsuHitWindow(overallDifficulty);
     }
     strainValueAt(current) {
         this.currentRhythmMultiplier =
-            DroidRhythmEvaluator.evaluateDifficultyOf(current, this.hitWindow.hitWindowFor300());
+            DroidRhythmEvaluator.evaluateDifficultyOf(current);
         this.currentRhythmStrain *= this.strainDecay(current.deltaTime);
         this.currentRhythmStrain += this.currentRhythmMultiplier - 1;
         return this.currentRhythmStrain;
@@ -1318,11 +1384,12 @@ class DroidVisualEvaluator {
             // Invert the scaling factor to determine the true travel distance independent of circle size.
             const pixelTravelDistance = current.object.lazyTravelDistance / scalingFactor;
             const currentVelocity = pixelTravelDistance / current.travelTime;
+            const spanTravelDistance = pixelTravelDistance / current.object.spanCount;
             strain +=
                 // Reward sliders based on velocity, while also avoiding overbuffing extremely fast sliders.
                 Math.min(6, currentVelocity * 1.5) *
                     // Longer sliders require more reading.
-                    (pixelTravelDistance / 100);
+                    (spanTravelDistance / 100);
             let cumulativeStrainTime = 0;
             // Reward for velocity changes based on last few sliders.
             for (let i = 0; i < Math.min(current.index, 4); ++i) {
@@ -1334,14 +1401,15 @@ class DroidVisualEvaluator {
                     continue;
                 }
                 // Invert the scaling factor to determine the true travel distance independent of circle size.
-                const pixelTravelDistance = last.object.lazyTravelDistance / scalingFactor;
-                const lastVelocity = pixelTravelDistance / last.travelTime;
+                const lastPixelTravelDistance = last.object.lazyTravelDistance / scalingFactor;
+                const lastVelocity = lastPixelTravelDistance / last.travelTime;
+                const lastSpanTravelDistance = lastPixelTravelDistance / last.object.spanCount;
                 strain +=
                     // Reward past sliders based on velocity changes, while also
                     // avoiding overbuffing extremely fast velocity changes.
                     Math.min(10, 2.5 * Math.abs(currentVelocity - lastVelocity)) *
                         // Longer sliders require more reading.
-                        (pixelTravelDistance / 125) *
+                        (lastSpanTravelDistance / 125) *
                         // Avoid overbuffing past sliders.
                         Math.min(1, 300 / cumulativeStrainTime);
             }
@@ -1417,10 +1485,10 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
      * @param lastLastObject The hitobject before the last hitobject.
      * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
      * @param clockRate The clock rate of the beatmap.
-     * @param isForceAR Whether force AR is enabled.
+     * @param greatWindow The great window of the hitobject.
      */
-    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, isForceAR) {
-        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate);
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, greatWindow) {
+        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, greatWindow);
         /**
          * The tap strain generated by the hitobject.
          */
@@ -1463,10 +1531,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);
@@ -1478,6 +1543,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.
      */
@@ -1485,23 +1553,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.deltaTime >= 5) {
+        if (this.object.startTime !== prev.object.startTime) {
             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 (!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 (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;
     }
@@ -1559,7 +1652,9 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
             Math.max(0, 1 - distance / (2.5 * this.object.radius)) *
                 (7.5 /
                     (1 +
-                        Math.exp(0.15 * (Math.max(deltaTime, this.minDeltaTime) - 75))));
+                        Math.exp(0.15 *
+                            (Math.max(deltaTime, DifficultyHitObject.minDeltaTime) -
+                                75))));
     }
 }
 
@@ -1583,7 +1678,6 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             speedNoteCount: 0,
             sliderFactor: 0,
             clockRate: 1,
-            approachRate: 0,
             overallDifficulty: 0,
             hitCircleCount: 0,
             sliderCount: 0,
@@ -1633,30 +1727,7 @@ 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) });
     }
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
@@ -1671,11 +1742,10 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * Calculates the tap star rating of the beatmap and stores it in this instance.
      */
     calculateTap() {
-        const od = this.difficultyStatistics.overallDifficulty;
-        const tapSkillCheese = new DroidTap(this.mods, od, true);
-        const tapSkillNoCheese = new DroidTap(this.mods, od, false);
+        const tapSkillCheese = new DroidTap(this.mods, true);
+        const tapSkillNoCheese = new DroidTap(this.mods, false);
         this.calculateSkills(tapSkillCheese, tapSkillNoCheese);
-        const tapSkillVibro = new DroidTap(this.mods, od, true, tapSkillCheese.relevantDeltaTime());
+        const tapSkillVibro = new DroidTap(this.mods, true, tapSkillCheese.relevantDeltaTime());
         this.calculateSkills(tapSkillVibro);
         this.postCalculateTap(tapSkillCheese, tapSkillVibro);
     }
@@ -1683,7 +1753,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * Calculates the rhythm star rating of the beatmap and stores it in this instance.
      */
     calculateRhythm() {
-        const rhythmSkill = new DroidRhythm(this.mods, this.difficultyStatistics.overallDifficulty);
+        const rhythmSkill = new DroidRhythm(this.mods);
         this.calculateSkills(rhythmSkill);
         this.postCalculateRhythm(rhythmSkill);
     }
@@ -1743,7 +1813,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         const flashlightSkillWithoutSliders = skills[6];
         const visualSkill = skills[7];
         const visualSkillWithoutSliders = skills[8];
-        const tapSkillVibro = new DroidTap(this.mods, this.difficultyStatistics.overallDifficulty, true, tapSkillCheese.relevantDeltaTime());
+        const tapSkillVibro = new DroidTap(this.mods, true, tapSkillCheese.relevantDeltaTime());
         this.calculateSkills(tapSkillVibro);
         this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
         this.postCalculateTap(tapSkillCheese, tapSkillVibro);
@@ -1766,42 +1836,29 @@ 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 { 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, (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) {
-        var _a;
-        const { difficulty } = this.beatmap;
-        return osuBase.calculateDroidDifficultyStatistics({
-            circleSize: difficulty.cs,
-            approachRate: (_a = difficulty.ar) !== null && _a !== void 0 ? _a : difficulty.od,
-            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() {
-        const od = this.difficultyStatistics.overallDifficulty;
         return [
             new DroidAim(this.mods, true),
             new DroidAim(this.mods, false),
             // Tap skill depends on rhythm skill, so we put it first
-            new DroidRhythm(this.mods, od),
+            new DroidRhythm(this.mods),
             // Cheesability tap
-            new DroidTap(this.mods, od, true),
+            new DroidTap(this.mods, true),
             // Non-cheesability tap
-            new DroidTap(this.mods, od, false),
+            new DroidTap(this.mods, false),
             new DroidFlashlight(this.mods, true),
             new DroidFlashlight(this.mods, false),
             new DroidVisual(this.mods, true),
@@ -1817,7 +1874,9 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     postCalculateAim(aimSkill, aimSkillWithoutSliders) {
         this.strainPeaks.aimWithSliders = aimSkill.strainPeaks;
         this.strainPeaks.aimWithoutSliders = aimSkillWithoutSliders.strainPeaks;
-        this.attributes.aimDifficulty = this.starValue(aimSkill.difficultyValue());
+        this.attributes.aimDifficulty = this.mods.some((m) => m instanceof osuBase.ModAutopilot)
+            ? 0
+            : this.starValue(aimSkill.difficultyValue());
         if (this.aim) {
             this.attributes.sliderFactor =
                 this.starValue(aimSkillWithoutSliders.difficultyValue()) /
@@ -1834,6 +1893,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * Calculates aim-related attributes.
      */
     calculateAimAttributes() {
+        this.attributes.difficultSliders = [];
         const topDifficultSliders = [];
         for (let i = 0; i < this.objects.length; ++i) {
             const object = this.objects[i];
@@ -1954,10 +2014,12 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             this.attributes.flashlightSliderFactor =
                 this.starValue(flashlightSkillWithoutSliders.difficultyValue()) / this.flashlight;
         }
+        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            this.attributes.flashlightDifficulty *= 0.3;
+        }
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.attributes.flashlightDifficulty *= 0.7;
         }
-        this.attributes.flashlightDifficulty = this.flashlight;
         this.attributes.flashlightDifficultStrainCount =
             flashlightSkill.countDifficultStrains();
     }
@@ -1976,6 +2038,9 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
                 this.starValue(visualSkillWithoutSliders.difficultyValue()) /
                     this.visual;
         }
+        if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            this.attributes.visualDifficulty *= 0.8;
+        }
         this.attributes.visualDifficultStrainCount =
             visualSkillWithSliders.countDifficultStrains();
     }
@@ -2357,8 +2422,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         aimValue *= this._aimSliderCheesePenalty;
         // Scale the aim value with deviation.
         aimValue *=
-            1.05 *
-                Math.sqrt(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._deviation)));
+            1.025 *
+                Math.pow(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._deviation)), 0.475);
         // OD 7 SS stays the same.
         aimValue *= 0.98 + Math.pow(7, 2) / 2500;
         return aimValue;
@@ -2370,8 +2435,9 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         let tapValue = this.baseValue(this.difficultyAttributes.tapDifficulty);
         tapValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.tapDifficultStrainCount);
         // Scale the tap value with estimated full combo deviation.
-        // Require more objects to be present as object count can rack up easily in tap-oriented beatmaps.
-        tapValue *= this.calculateDeviationBasedLengthScaling(this.totalHits / 1.45);
+        // Consider notes that are difficult to tap with respect to other notes, but
+        // also cap the note count to prevent buffing filler patterns.
+        tapValue *= this.calculateDeviationBasedLengthScaling(Math.min(this.difficultyAttributes.speedNoteCount, this.totalHits / 1.45));
         // Normalize the deviation to 300 BPM.
         const normalizedDeviation = this.tapDeviation *
             Math.max(1, 50 / this.difficultyAttributes.averageSpeedDeltaTime);
@@ -2386,8 +2452,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
                             ((2 * 300) / averageBPM))));
         // Scale the tap value with tap deviation.
         tapValue *=
-            1.1 *
-                Math.pow(osuBase.ErrorFunction.erf(20 / (Math.SQRT2 * adjustedDeviation)), 0.625);
+            1.05 *
+                Math.pow(osuBase.ErrorFunction.erf(20 / (Math.SQRT2 * adjustedDeviation)), 0.6);
         // Additional scaling for tap value based on average BPM and how "vibroable" the beatmap is.
         // Higher BPMs require more precise tapping. When the deviation is too high,
         // it can be assumed that the player taps invariant to rhythm.
@@ -2412,7 +2478,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             this.totalSuccessfulHits === 0) {
             return 0;
         }
-        let accuracyValue = 800 * Math.exp(-0.1 * this._deviation);
+        let accuracyValue = 650 * Math.exp(-0.1 * this._deviation);
         const ncircles = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModScoreV2)
             ? this.totalHits - this.difficultyAttributes.spinnerCount
             : this.difficultyAttributes.hitCircleCount;
@@ -2465,8 +2531,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         visualValue *= this._visualSliderCheesePenalty;
         // Scale the visual value with deviation.
         visualValue *=
-            1.065 *
-                Math.pow(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._deviation)), 0.8);
+            1.05 *
+                Math.pow(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._deviation)), 0.775);
         // OD 5 SS stays the same.
         visualValue *= 0.98 + Math.pow(5, 2) / 2500;
         return visualValue;
@@ -2482,8 +2548,9 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (this.effectiveMissCount === 0) {
             return 1;
         }
-        return (0.94 /
-            (this.effectiveMissCount / (2 * Math.sqrt(difficultStrainCount)) +
+        return (0.96 /
+            (this.effectiveMissCount /
+                (4 * Math.pow(Math.log(difficultStrainCount), 0.94)) +
                 1));
     }
     /**
@@ -2910,30 +2977,19 @@ class OsuSpeedEvaluator extends SpeedEvaluator {
      * - and how easily they can be cheesed.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current, greatWindow) {
+    static evaluateDifficultyOf(current) {
         var _a;
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
         const prev = current.previous(0);
         let strainTime = current.strainTime;
-        const greatWindowFull = greatWindow * 2;
         // Nerf doubletappable doubles.
-        const next = current.next(0);
-        let doubletapness = 1;
-        if (next) {
-            const currentDeltaTime = Math.max(1, current.deltaTime);
-            const nextDeltaTime = Math.max(1, next.deltaTime);
-            const deltaDifference = Math.abs(nextDeltaTime - currentDeltaTime);
-            const speedRatio = currentDeltaTime / Math.max(currentDeltaTime, deltaDifference);
-            const windowRatio = Math.pow(Math.min(1, currentDeltaTime / greatWindowFull), 2);
-            doubletapness = Math.pow(speedRatio, 1 - windowRatio);
-        }
+        const doubletapness = 1 - current.doubletapness;
         // Cap deltatime to the OD 300 hitwindow.
         // 0.93 is derived from making sure 260 BPM 1/4 OD8 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.
-        strainTime /= osuBase.MathUtils.clamp(strainTime / greatWindowFull / 0.93, 0.92, 1);
+        strainTime /= osuBase.MathUtils.clamp(strainTime / current.fullGreatWindow / 0.93, 0.92, 1);
         let speedBonus = 1;
         if (strainTime < this.minSpeedBonus) {
             speedBonus +=
@@ -2956,7 +3012,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.
@@ -2964,7 +3020,7 @@ class OsuRhythmEvaluator extends RhythmEvaluator {
      * @param current The current object.
      * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current, greatWindow) {
+    static evaluateDifficultyOf(current) {
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
@@ -2999,8 +3055,9 @@ class OsuRhythmEvaluator extends RhythmEvaluator {
                     Math.min(0.5, Math.pow(Math.sin(Math.PI /
                         (Math.min(prevDelta, currentDelta) /
                             Math.max(prevDelta, currentDelta))), 2));
-            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - greatWindow * 0.6) /
-                (greatWindow * 0.6));
+            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) -
+                current.fullGreatWindow * 0.3) /
+                (current.fullGreatWindow * 0.3));
             let effectiveRatio = windowPenalty * currentRatio;
             if (firstDeltaSwitch) {
                 if (prevDelta <= 1.25 * currentDelta &&
@@ -3061,13 +3118,15 @@ 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.
  */
 class OsuSpeed extends OsuSkill {
-    constructor(mods, overallDifficulty) {
-        super(mods);
+    constructor() {
+        super(...arguments);
         this.strainDecayBase = 0.3;
         this.reducedSectionCount = 5;
         this.reducedSectionBaseline = 0.75;
@@ -3076,7 +3135,6 @@ class OsuSpeed extends OsuSkill {
         this.currentSpeedStrain = 0;
         this.currentRhythm = 0;
         this.skillMultiplier = 1375;
-        this.greatWindow = new osuBase.OsuHitWindow(overallDifficulty).hitWindowFor300();
     }
     /**
      * @param current The hitobject to calculate.
@@ -3084,9 +3142,9 @@ class OsuSpeed extends OsuSkill {
     strainValueAt(current) {
         this.currentSpeedStrain *= this.strainDecay(current.strainTime);
         this.currentSpeedStrain +=
-            OsuSpeedEvaluator.evaluateDifficultyOf(current, this.greatWindow) *
+            OsuSpeedEvaluator.evaluateDifficultyOf(current) *
                 this.skillMultiplier;
-        this.currentRhythm = OsuRhythmEvaluator.evaluateDifficultyOf(current, this.greatWindow);
+        this.currentRhythm = OsuRhythmEvaluator.evaluateDifficultyOf(current);
         return this.currentSpeedStrain * this.currentRhythm;
     }
     calculateInitialStrain(time, current) {
@@ -3220,29 +3278,8 @@ class OsuFlashlight extends OsuSkill {
  * Represents an osu!standard hit object with difficulty calculation values.
  */
 class OsuDifficultyHitObject extends DifficultyHitObject {
-    get scalingFactor() {
-        const radius = this.object.radius;
-        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
-        let scalingFactor = this.normalizedRadius / radius;
-        // High circle size (small CS) bonus
-        if (radius < this.radiusBuffThreshold) {
-            scalingFactor *=
-                1 + Math.min(this.radiusBuffThreshold - radius, 5) / 50;
-        }
-        return scalingFactor;
-    }
-    /**
-     * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
-     * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue).
-     *
-     * @param object The underlying hitobject.
-     * @param lastObject The hitobject before this hitobject.
-     * @param lastLastObject The hitobject before the last hitobject.
-     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
-     * @param clockRate The clock rate of the beatmap.
-     */
-    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate) {
-        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate);
+    constructor() {
+        super(...arguments);
         /**
          * The speed strain generated by the hitobject.
          */
@@ -3254,6 +3291,17 @@ class OsuDifficultyHitObject extends DifficultyHitObject {
         this.radiusBuffThreshold = 30;
         this.mode = osuBase.Modes.osu;
     }
+    get scalingFactor() {
+        const radius = this.object.radius;
+        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
+        let scalingFactor = this.normalizedRadius / radius;
+        // High circle size (small CS) bonus
+        if (radius < this.radiusBuffThreshold) {
+            scalingFactor *=
+                1 + Math.min(this.radiusBuffThreshold - radius, 5) / 50;
+        }
+        return scalingFactor;
+    }
 }
 
 /**
@@ -3319,7 +3367,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             this.attributes.speedDifficulty = 0;
             return;
         }
-        const speedSkill = new OsuSpeed(this.mods, this.difficultyStatistics.overallDifficulty);
+        const speedSkill = new OsuSpeed(this.mods);
         this.calculateSkills(speedSkill);
         this.postCalculateSpeed(speedSkill);
     }
@@ -3383,37 +3431,32 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             this.flashlight.toFixed(2) +
             " flashlight)");
     }
-    generateDifficultyHitObjects(convertedBeatmap) {
+    generateDifficultyHitObjects(beatmap, clockRate) {
         var _a, _b;
         const difficultyObjects = [];
-        const { objects } = convertedBeatmap.hitObjects;
+        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);
-            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) {
-        var _a;
-        const { difficulty } = this.beatmap;
-        return osuBase.calculateOsuDifficultyStatistics({
-            circleSize: difficulty.cs,
-            approachRate: (_a = difficulty.ar) !== null && _a !== void 0 ? _a : difficulty.od,
-            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),
             new OsuAim(this.mods, false),
-            new OsuSpeed(this.mods, this.difficultyStatistics.overallDifficulty),
+            new OsuSpeed(this.mods),
             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.
      *
@@ -3720,6 +3763,5 @@ exports.OsuRhythmEvaluator = OsuRhythmEvaluator;
 exports.OsuSpeed = OsuSpeed;
 exports.OsuSpeedEvaluator = OsuSpeedEvaluator;
 exports.PerformanceCalculator = PerformanceCalculator;
-exports.RhythmEvaluator = RhythmEvaluator;
 exports.SpeedEvaluator = SpeedEvaluator;
 //# sourceMappingURL=index.js.map