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

package/dist/index.js

@@ -44,7 +44,6 @@ class DifficultyCalculator {
      * @param beatmap The beatmap to calculate. This beatmap will be deep-cloned to prevent reference changes.
      */
     constructor(beatmap) {
-        var _a;
         /**
          * The difficulty objects of the beatmap.
          */
@@ -65,7 +64,7 @@ class DifficultyCalculator {
         this.beatmap = beatmap;
         this.difficultyStatistics = {
             circleSize: beatmap.difficulty.cs,
-            approachRate: (_a = beatmap.difficulty.ar) !== null && _a !== void 0 ? _a : beatmap.difficulty.od,
+            approachRate: beatmap.difficulty.ar,
             overallDifficulty: beatmap.difficulty.od,
             healthDrain: beatmap.difficulty.hp,
             overallSpeedMultiplier: 1,
@@ -89,14 +88,14 @@ class DifficultyCalculator {
     calculate(options) {
         var _a;
         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));
+        this.objects.push(...this.generateDifficultyHitObjects(playableBeatmap));
         this.calculateAll();
         return this;
     }
@@ -159,8 +158,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 +213,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 +295,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 +324,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 +342,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 +458,10 @@ class DifficultyHitObject {
         return pos;
     }
 }
+/**
+ * The lowest possible delta time value.
+ */
+DifficultyHitObject.minDeltaTime = 25;
 
 /**
  * An evaluator for calculating osu!droid Aim skill.
@@ -692,6 +714,7 @@ class DroidSkill extends StrainSkill {
     constructor() {
         super(...arguments);
         this._objectStrains = [];
+        this.difficulty = 0;
     }
     /**
      * The strains of hitobjects.
@@ -705,14 +728,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) {
-            return 0;
-        }
-        const maxStrain = Math.max(...this._objectStrains);
-        if (maxStrain === 0) {
+        if (this.difficulty === 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 +753,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 +834,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 +868,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 +878,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 +916,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;
@@ -1089,6 +1100,46 @@ 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;
+        }
+        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;
+    }
+    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);
+    }
+    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;
+    }
+}
 /**
  * An evaluator for calculating osu!droid Rhythm skill.
  */
@@ -1098,22 +1149,23 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
      * 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) {
+    static evaluateDifficultyOf(current) {
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
             current.isOverlapping(false)) {
             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) {
@@ -1137,105 +1189,125 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
                 this.historyTimeMax;
             // 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 currentObject = validPrevious[i - 1];
+            const prevObject = validPrevious[i];
+            const lastObject = validPrevious[i + 1];
+            const currentDelta = currentObject.strainTime;
+            const prevDelta = prevObject.strainTime;
+            const lastDelta = lastObject.strainTime;
             const currentRatio = 1 +
-                6 *
+                10 *
                     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 = osuBase.MathUtils.clamp((Math.abs(prevDelta - currentDelta) - deltaDifferenceEpsilon) /
+                deltaDifferenceEpsilon, 0, 1);
             let effectiveRatio = windowPenalty * currentRatio;
             if (firstDeltaSwitch) {
-                if (prevDelta <= 1.25 * currentDelta &&
-                    prevDelta * 1.25 >= currentDelta) {
-                    // Island is still progressing, count size.
-                    if (islandSize < 7) {
-                        ++islandSize;
+                if (Math.abs(prevDelta - currentDelta) <= deltaDifferenceEpsilon) {
+                    if (island.deltas.length < this.maxIslandSize) {
+                        // Island is still progressing.
+                        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.
+                    // 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.
+                    if (prevObject.object instanceof osuBase.Slider) {
                         effectiveRatio /= 4;
                     }
-                    if (previousIslandSize === islandSize) {
-                        // Repeated island size (ex: triplet -> triplet).
-                        effectiveRatio /= 4;
+                    // Repeated island polarity (2 -> 4, 3 -> 5).
+                    if (island.isSimilarPolarity(previousIsland)) {
+                        effectiveRatio *= 0.3;
                     }
-                    if (previousIslandSize % 2 === islandSize % 2) {
-                        // Repeated island polarity (2 -> 4, 3 -> 5).
+                    // 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;
+                    }
+                    // Singletaps are easier to control.
+                    if (island.deltas.length === 1) {
                         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.
-                        effectiveRatio /= 8;
+                    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(1 / islandCount, Math.pow(1 / islandCount, 4 /
+                            (1 +
+                                Math.exp(10 - 0.165 * island.averageDelta))));
+                        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(Math.trunc(currentDelta), deltaDifferenceEpsilon);
                 }
             }
-            else if (prevDelta > 1.25 * currentDelta) {
-                // We want to be speeding up.
+            else if (prevDelta > deltaDifferenceEpsilon + currentDelta) {
+                // We're speeding up.
                 // Begin counting island until we change speed again.
                 firstDeltaSwitch = true;
+                // Reduce ratio if we're starting after a slider.
+                if (prevObject.object instanceof osuBase.Slider) {
+                    effectiveRatio *= 0.3;
+                }
                 startRatio = effectiveRatio;
-                islandSize = 1;
+                island = new Island(Math.trunc(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.rhythmMultiplier) / 2;
     }
 }
+DroidRhythmEvaluator.rhythmMultiplier = 1.2;
+DroidRhythmEvaluator.historyTimeMax = 4000;
+DroidRhythmEvaluator.maxIslandSize = 7;
+DroidRhythmEvaluator.historyObjectsMax = 24;
 
 /**
  * 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 +1390,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 +1407,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 +1491,11 @@ 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 greatWindow The great window of the hitobject.
      * @param isForceAR Whether force AR is enabled.
      */
-    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, isForceAR) {
-        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate);
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, greatWindow, isForceAR) {
+        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, greatWindow);
         /**
          * The tap strain generated by the hitobject.
          */
@@ -1559,7 +1634,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))));
     }
 }
 
@@ -1671,11 +1748,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 +1759,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 +1819,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);
@@ -1771,19 +1847,19 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         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();
         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);
+            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);
             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,
+            approachRate: difficulty.ar,
             overallDifficulty: difficulty.od,
             healthDrain: difficulty.hp,
             mods: this.mods,
@@ -1792,16 +1868,15 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         });
     }
     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 +1892,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 +1911,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 +2032,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 +2056,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 +2440,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 +2453,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 +2470,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 +2496,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 +2549,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 +2566,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 +2995,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 +=
@@ -2964,7 +3038,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 +3073,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 &&
@@ -3066,8 +3141,8 @@ class OsuRhythmEvaluator extends RhythmEvaluator {
  * 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 +3151,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 +3158,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 +3294,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 +3307,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 +3383,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);
     }
@@ -3387,19 +3451,19 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         var _a, _b;
         const difficultyObjects = [];
         const { objects } = convertedBeatmap.hitObjects;
+        const greatWindow = new osuBase.OsuHitWindow(this.difficultyStatistics.overallDifficulty).hitWindowFor300();
         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);
+            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);
             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,
+            approachRate: difficulty.ar,
             overallDifficulty: difficulty.od,
             healthDrain: difficulty.hp,
             mods: options === null || options === void 0 ? void 0 : options.mods,
@@ -3410,7 +3474,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         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),
         ];
     }

package/package.json

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

package/typings/index.d.ts

@@ -191,6 +191,10 @@ declare abstract class DifficultyHitObject {
      * Adjusted end time of the hitobject, taking speed multiplier into account.
      */
     readonly endTime: number;
+    /**
+     * The full great window of the hitobject.
+     */
+    readonly fullGreatWindow: number;
     /**
      * Other hitobjects in the beatmap, including this hitobject.
      */
@@ -199,7 +203,10 @@ declare abstract class DifficultyHitObject {
     protected readonly normalizedRadius = 50;
     protected readonly maximumSliderRadius: number;
     protected readonly assumedSliderRadius: number;
-    protected readonly minDeltaTime = 25;
+    /**
+     * The lowest possible delta time value.
+     */
+    static readonly minDeltaTime = 25;
     private readonly lastObject;
     private readonly lastLastObject;
     /**
@@ -211,8 +218,9 @@ declare abstract 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.
      */
-    protected constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number);
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, greatWindow: number);
     /**
      * Computes the properties of this hitobject.
      *
@@ -250,6 +258,13 @@ declare abstract class DifficultyHitObject {
      * @returns The opacity of the hitobject at the given time.
      */
     opacityAt(time: number, isHidden: boolean): number;
+    /**
+     * 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(): number;
     protected abstract get scalingFactor(): number;
     protected setDistances(clockRate: number): void;
     private calculateSliderCursorPosition;
@@ -521,6 +536,7 @@ declare abstract class DroidSkill extends StrainSkill {
      * The strains of hitobjects.
      */
     get objectStrains(): readonly number[];
+    private difficulty;
     /**
      * Returns the number of strains weighed against the top strain.
      *
@@ -599,9 +615,10 @@ declare 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 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, isForceAR: boolean);
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, greatWindow: number, isForceAR: boolean);
     computeProperties(clockRate: number, hitObjects: readonly PlaceableHitObject[]): void;
     /**
      * Determines whether this hitobject is considered overlapping with the hitobject before it.
@@ -1243,8 +1260,6 @@ declare class DroidRhythm extends DroidSkill {
     protected readonly starsPerDouble = 1.75;
     private currentRhythmStrain;
     private currentRhythmMultiplier;
-    private readonly hitWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
     protected getObjectStrain(): number;
@@ -1265,14 +1280,17 @@ declare abstract class RhythmEvaluator {
  * 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;
+    private static readonly historyObjectsMax;
     /**
      * 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: DroidDifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject): number;
 }
 
 /**
@@ -1286,7 +1304,6 @@ declare class DroidTap extends DroidSkill {
     private currentTapStrain;
     private currentRhythmMultiplier;
     private readonly skillMultiplier;
-    private readonly greatWindow;
     private readonly considerCheesability;
     private readonly strainTimeCap?;
     private readonly _objectDeltaTimes;
@@ -1294,7 +1311,7 @@ declare class DroidTap extends DroidSkill {
      * The delta time of hitobjects.
      */
     get objectDeltaTimes(): readonly number[];
-    constructor(mods: Mod[], overallDifficulty: number, considerCheesability: boolean, strainTimeCap?: number);
+    constructor(mods: Mod[], considerCheesability: boolean, strainTimeCap?: number);
     /**
      * The amount of notes that are relevant to the difficulty.
      */
@@ -1338,7 +1355,7 @@ declare abstract 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: DroidDifficultyHitObject, greatWindow: number, considerCheesability: boolean, strainTimeCap?: number): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, considerCheesability: boolean, strainTimeCap?: number): number;
 }
 
 /**
@@ -1420,17 +1437,6 @@ declare class OsuDifficultyHitObject extends DifficultyHitObject {
     private readonly radiusBuffThreshold;
     protected readonly mode = Modes.osu;
     protected get scalingFactor(): number;
-    /**
-     * 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: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number);
 }
 
 /**
@@ -1634,7 +1640,7 @@ declare abstract class OsuRhythmEvaluator extends RhythmEvaluator {
      * @param current The current object.
      * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current: OsuDifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
 }
 
 /**
@@ -1649,8 +1655,6 @@ declare class OsuSpeed extends OsuSkill {
     private currentSpeedStrain;
     private currentRhythm;
     private readonly skillMultiplier;
-    private readonly greatWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
     /**
      * @param current The hitobject to calculate.
      */
@@ -1678,9 +1682,8 @@ declare abstract 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: OsuDifficultyHitObject, greatWindow: number): number;
+    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 };