@rian8337/osu-difficulty-calculator 4.0.0-beta.19 → 4.0.0-beta.20

package/dist/index.js

@@ -152,16 +152,13 @@ class DifficultyCalculator {
 class DifficultyHitObject {
     /**
      * 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.).
+     * 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.
-     * @param timePreempt The time preempt with clock rate.
-     * @param isForceAR Whether force AR is enabled.
-     * @param mode The gamemode to compute properties for.
      */
     constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate) {
         /**
@@ -625,9 +622,7 @@ class StrainSkill extends Skill {
     process(current) {
         // The first object doesn't generate a strain, so we begin with an incremented section end
         if (current.index === 0) {
-            this.currentSectionEnd =
-                Math.ceil(current.startTime / this.sectionLength) *
-                    this.sectionLength;
+            this.currentSectionEnd = this.calculateCurrentSectionStart(current);
         }
         while (current.startTime > this.currentSectionEnd) {
             this.saveCurrentPeak();
@@ -657,6 +652,16 @@ class StrainSkill extends Skill {
     strainDecay(ms) {
         return Math.pow(this.strainDecayBase, ms / 1000);
     }
+    /**
+     * Calculates the starting time of a strain section at an object.
+     *
+     * @param current The object at which the strain section starts.
+     * @returns The start time of the strain section.
+     */
+    calculateCurrentSectionStart(current) {
+        return (Math.ceil(current.startTime / this.sectionLength) *
+            this.sectionLength);
+    }
     /**
      * Sets the initial strain level for a new section.
      *
@@ -675,6 +680,35 @@ class StrainSkill extends Skill {
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
  */
 class DroidSkill extends StrainSkill {
+    constructor() {
+        super(...arguments);
+        this._objectStrains = [];
+    }
+    /**
+     * The strains of hitobjects.
+     */
+    get objectStrains() {
+        return this._objectStrains;
+    }
+    /**
+     * Returns the number of strains weighed against the top strain.
+     *
+     * 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) {
+            return 0;
+        }
+        return this._objectStrains.reduce((total, next) => total + Math.pow(next / maxStrain, 4), 0);
+    }
+    process(current) {
+        super.process(current);
+        this._objectStrains.push(this.getObjectStrain(current));
+    }
     difficultyValue() {
         const strains = this.strainPeaks.slice();
         if (this.reducedSectionCount > 0) {
@@ -694,6 +728,9 @@ class DroidSkill extends StrainSkill {
             return a + Math.pow(v, 1 / Math.log2(this.starsPerDouble));
         }, 0), Math.log2(this.starsPerDouble));
     }
+    calculateCurrentSectionStart(current) {
+        return current.startTime;
+    }
 }
 
 /**
@@ -722,6 +759,9 @@ class DroidAim extends DroidSkill {
         return (this.currentAimStrain *
             this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
+    getObjectStrain() {
+        return this.currentAimStrain;
+    }
     /**
      * @param current The hitobject to save to.
      */
@@ -754,13 +794,15 @@ class DroidTapEvaluator extends SpeedEvaluator {
      *
      * - time between pressing the previous and current object,
      * - distance between those objects,
-     * - and how easily they can be cheesed.
+     * - how easily they can be cheesed,
+     * - and the strain time cap.
      *
      * @param current The current object.
      * @param greatWindow The great hit window of the current object.
      * @param considerCheesability Whether to consider cheesability.
+     * @param strainTimeCap The strain time to cap the object's strain time to.
      */
-    static evaluateDifficultyOf(current, greatWindow, considerCheesability) {
+    static evaluateDifficultyOf(current, greatWindow, considerCheesability, strainTimeCap) {
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
             current.isOverlapping(false)) {
@@ -781,13 +823,17 @@ class DroidTapEvaluator extends SpeedEvaluator {
                 doubletapness = Math.pow(speedRatio, 1 - windowRatio);
             }
         }
+        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)
+            : current.strainTime;
         let speedBonus = 1;
-        if (current.strainTime < this.minSpeedBonus) {
+        if (strainTime < this.minSpeedBonus) {
             speedBonus +=
                 0.75 *
-                    Math.pow(osuBase.ErrorFunction.erf((this.minSpeedBonus - current.strainTime) / 40), 2);
+                    Math.pow(osuBase.ErrorFunction.erf((this.minSpeedBonus - strainTime) / 40), 2);
         }
-        return (speedBonus * Math.pow(doubletapness, 1.5)) / current.strainTime;
+        return (speedBonus * Math.pow(doubletapness, 1.5)) / strainTime;
     }
 }
 
@@ -795,7 +841,13 @@ class DroidTapEvaluator extends SpeedEvaluator {
  * 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 DroidTap extends DroidSkill {
-    constructor(mods, overallDifficulty, considerCheesability) {
+    /**
+     * The delta time of hitobjects.
+     */
+    get objectDeltaTimes() {
+        return this._objectDeltaTimes;
+    }
+    constructor(mods, overallDifficulty, considerCheesability, strainTimeCap) {
         super(mods);
         this.reducedSectionCount = 10;
         this.reducedSectionBaseline = 0.75;
@@ -804,15 +856,49 @@ class DroidTap extends DroidSkill {
         this.currentTapStrain = 0;
         this.currentRhythmMultiplier = 0;
         this.skillMultiplier = 1375;
+        this._objectDeltaTimes = [];
         this.greatWindow = new osuBase.OsuHitWindow(overallDifficulty).hitWindowFor300();
         this.considerCheesability = considerCheesability;
+        this.strainTimeCap = strainTimeCap;
+    }
+    /**
+     * The amount of notes that are relevant to the difficulty.
+     */
+    relevantNoteCount() {
+        if (this._objectStrains.length === 0) {
+            return 0;
+        }
+        const maxStrain = Math.max(...this._objectStrains);
+        if (maxStrain === 0) {
+            return 0;
+        }
+        return this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
+    }
+    /**
+     * The delta time relevant to the difficulty.
+     */
+    relevantDeltaTime() {
+        if (this._objectStrains.length === 0) {
+            return 0;
+        }
+        const maxStrain = Math.max(...this._objectStrains);
+        if (maxStrain === 0) {
+            return 0;
+        }
+        return (this._objectDeltaTimes.reduce((total, next, index) => total +
+            (next * 1) /
+                (1 +
+                    Math.exp(-((this._objectStrains[index] / maxStrain) *
+                        25 -
+                        20))), 0) /
+            this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 25 - 20))), 0));
     }
     strainValueAt(current) {
-        const decay = this.strainDecay(current.strainTime);
-        this.currentTapStrain *= decay;
+        this.currentTapStrain *= this.strainDecay(current.strainTime);
         this.currentTapStrain +=
-            DroidTapEvaluator.evaluateDifficultyOf(current, this.greatWindow, this.considerCheesability) * this.skillMultiplier;
+            DroidTapEvaluator.evaluateDifficultyOf(current, this.greatWindow, this.considerCheesability, this.strainTimeCap) * this.skillMultiplier;
         this.currentRhythmMultiplier = current.rhythmMultiplier;
+        this._objectDeltaTimes.push(current.deltaTime);
         return this.currentTapStrain * current.rhythmMultiplier;
     }
     calculateInitialStrain(time, current) {
@@ -821,10 +907,16 @@ class DroidTap extends DroidSkill {
             this.currentRhythmMultiplier *
             this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
+    getObjectStrain() {
+        return this.currentTapStrain * this.currentRhythmMultiplier;
+    }
     /**
      * @param current The hitobject to save to.
      */
     saveToHitObject(current) {
+        if (this.strainTimeCap !== undefined) {
+            return;
+        }
         const strain = this.currentTapStrain * this.currentRhythmMultiplier;
         if (this.considerCheesability) {
             current.tapStrain = strain;
@@ -961,6 +1053,9 @@ class DroidFlashlight extends DroidSkill {
         return (this.currentFlashlightStrain *
             this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
+    getObjectStrain() {
+        return this.currentFlashlightStrain;
+    }
     saveToHitObject(current) {
         if (this.withSliders) {
             current.flashlightStrainWithSliders = this.currentFlashlightStrain;
@@ -1141,6 +1236,9 @@ class DroidRhythm extends DroidSkill {
         return (this.currentRhythmStrain *
             this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
+    getObjectStrain() {
+        return this.currentRhythmStrain;
+    }
     saveToHitObject(current) {
         current.rhythmStrain = this.currentRhythmStrain;
         current.rhythmMultiplier = this.currentRhythmMultiplier;
@@ -1148,7 +1246,7 @@ class DroidRhythm extends DroidSkill {
 }
 
 /**
- * An evaluator for calculating osu!droid Visual skill.
+ * An evaluator for calculating osu!droid visual skill.
  */
 class DroidVisualEvaluator {
     /**
@@ -1200,12 +1298,12 @@ class DroidVisualEvaluator {
                     current.opacityAt(previous.object.startTime, isHiddenMod)) /
                     4;
         }
-        // Scale the value with overlapping factor.
-        strain /= 10 * (1 + current.overlappingFactor);
         if (current.timePreempt < 400) {
             // Give bonus for AR higher than 10.33.
-            strain += Math.pow(400 - current.timePreempt, 1.3) / 100;
+            strain += Math.pow(400 - current.timePreempt, 1.35) / 100;
         }
+        // Scale the value with overlapping factor.
+        strain /= 10 * (1 + current.overlappingFactor);
         if (current.object instanceof osuBase.Slider && withSliders) {
             const scalingFactor = 50 / current.object.radius;
             // Invert the scaling factor to determine the true travel distance independent of circle size.
@@ -1272,6 +1370,9 @@ class DroidVisual extends DroidSkill {
             this.currentRhythmMultiplier *
             this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
     }
+    getObjectStrain() {
+        return this.currentVisualStrain * this.currentRhythmMultiplier;
+    }
     saveToHitObject(current) {
         const strain = this.currentVisualStrain * this.currentRhythmMultiplier;
         if (this.withSliders) {
@@ -1300,7 +1401,7 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
     }
     /**
      * 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.).
+     * 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.
@@ -1446,7 +1547,7 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
         // Penalize objects that are too close to the object in both distance
         // and delta time to prevent stream maps from being overweighted.
         this.overlappingFactor +=
-            Math.max(0, 1 - distance / (3 * this.object.radius)) *
+            Math.max(0, 1 - distance / (2.5 * this.object.radius)) *
                 (7.5 /
                     (1 +
                         Math.exp(0.15 * (Math.max(deltaTime, this.minDeltaTime) - 75))));
@@ -1487,6 +1588,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             possibleThreeFingeredSections: [],
             difficultSliders: [],
             averageSpeedDeltaTime: 0,
+            vibroFactor: 1,
         };
         this.difficultyMultiplier = 0.18;
         this.mode = osuBase.Modes.droid;
@@ -1544,11 +1646,9 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             flashlightDifficultStrainCount: this.attributes.flashlightDifficultStrainCount,
             visualDifficultStrainCount: this.attributes.visualDifficultStrainCount,
             averageSpeedDeltaTime: this.attributes.averageSpeedDeltaTime,
+            vibroFactor: this.attributes.vibroFactor,
         };
     }
-    calculate(options) {
-        return super.calculate(options);
-    }
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -1566,7 +1666,9 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         const tapSkillCheese = new DroidTap(this.mods, od, true);
         const tapSkillNoCheese = new DroidTap(this.mods, od, false);
         this.calculateSkills(tapSkillCheese, tapSkillNoCheese);
-        this.postCalculateTap(tapSkillCheese);
+        const tapSkillVibro = new DroidTap(this.mods, od, true, tapSkillCheese.relevantDeltaTime());
+        this.calculateSkills(tapSkillVibro);
+        this.postCalculateTap(tapSkillCheese, tapSkillVibro);
     }
     /**
      * Calculates the rhythm star rating of the beatmap and stores it in this instance.
@@ -1632,8 +1734,10 @@ 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());
+        this.calculateSkills(tapSkillVibro);
         this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
-        this.postCalculateTap(tapSkillCheese);
+        this.postCalculateTap(tapSkillCheese, tapSkillVibro);
         this.postCalculateRhythm(rhythmSkill);
         this.postCalculateFlashlight(flashlightSkill, flashlightSkillWithoutSliders);
         this.postCalculateVisual(visualSkill, visualSkillWithoutSliders);
@@ -1685,7 +1789,9 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             new DroidAim(this.mods, false),
             // Tap skill depends on rhythm skill, so we put it first
             new DroidRhythm(this.mods, od),
+            // Cheesability tap
             new DroidTap(this.mods, od, true),
+            // Non-cheesability tap
             new DroidTap(this.mods, od, false),
             new DroidFlashlight(this.mods, true),
             new DroidFlashlight(this.mods, false),
@@ -1711,19 +1817,17 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.attributes.aimDifficulty *= 0.9;
         }
+        this.attributes.aimDifficultStrainCount =
+            aimSkill.countDifficultStrains();
         this.calculateAimAttributes();
     }
     /**
      * Calculates aim-related attributes.
      */
     calculateAimAttributes() {
-        const objectStrains = [];
-        let maxStrain = 0;
         const topDifficultSliders = [];
         for (let i = 0; i < this.objects.length; ++i) {
             const object = this.objects[i];
-            objectStrains.push(object.aimStrainWithSliders);
-            maxStrain = Math.max(maxStrain, object.aimStrainWithSliders);
             const velocity = object.travelDistance / object.travelTime;
             if (velocity > 0) {
                 topDifficultSliders.push({
@@ -1732,10 +1836,6 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
                 });
             }
         }
-        if (maxStrain) {
-            this.attributes.aimNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
-            this.attributes.aimDifficultStrainCount = objectStrains.reduce((total, next) => total + Math.pow(next / maxStrain, 4), 0);
-        }
         const velocitySum = topDifficultSliders.reduce((a, v) => a + v.velocity, 0);
         for (const slider of topDifficultSliders) {
             const difficultyRating = slider.velocity / velocitySum;
@@ -1758,16 +1858,22 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * Called after tap skill calculation.
      *
      * @param tapSkillCheese The tap skill that considers cheesing.
+     * @param tapSkillVibro The tap skill that considers vibro.
      */
-    postCalculateTap(tapSkillCheese) {
+    postCalculateTap(tapSkillCheese, tapSkillVibro) {
         this.strainPeaks.speed = tapSkillCheese.strainPeaks;
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.attributes.tapDifficulty = 0;
-            this.attributes.possibleThreeFingeredSections = [];
-        }
-        else {
-            this.attributes.tapDifficulty = this.starValue(tapSkillCheese.difficultyValue());
-        }
+        this.attributes.tapDifficulty = this.mods.some((m) => m instanceof osuBase.ModRelax)
+            ? 0
+            : this.starValue(tapSkillCheese.difficultyValue());
+        if (this.tap) {
+            this.attributes.vibroFactor =
+                this.starValue(tapSkillVibro.difficultyValue()) / this.tap;
+        }
+        this.attributes.speedNoteCount = tapSkillCheese.relevantNoteCount();
+        this.attributes.averageSpeedDeltaTime =
+            tapSkillCheese.relevantDeltaTime();
+        this.attributes.tapDifficultStrainCount =
+            tapSkillCheese.countDifficultStrains();
         this.calculateTapAttributes();
     }
     /**
@@ -1775,110 +1881,46 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      */
     calculateTapAttributes() {
         this.attributes.possibleThreeFingeredSections = [];
-        const tempSections = [];
-        const objectStrains = [];
-        const objectDeltaTimes = [];
-        let maxStrain = 0;
-        const maxSectionDeltaTime = 2000;
+        const { threeFingerStrainThreshold } = DroidDifficultyCalculator;
         const minSectionObjectCount = 5;
-        let firstObjectIndex = 0;
-        for (let i = 0; i < this.objects.length - 1; ++i) {
+        let inSpeedSection = false;
+        let firstSpeedObjectIndex = 0;
+        for (let i = 2; i < this.objects.length; ++i) {
             const current = this.objects[i];
-            const next = this.objects[i + 1];
-            if (i === 0) {
-                objectStrains.push(current.tapStrain);
-                objectDeltaTimes.push(current.deltaTime);
+            const prev = this.objects[i - 1];
+            if (!inSpeedSection &&
+                current.originalTapStrain >= threeFingerStrainThreshold) {
+                inSpeedSection = true;
+                firstSpeedObjectIndex = i;
+                continue;
             }
-            objectStrains.push(next.tapStrain);
-            objectDeltaTimes.push(next.deltaTime);
-            maxStrain = Math.max(current.tapStrain, maxStrain);
-            const realDeltaTime = next.object.startTime - current.object.endTime;
-            if (realDeltaTime >= maxSectionDeltaTime) {
+            const currentDelta = current.deltaTime;
+            const prevDelta = prev.deltaTime;
+            const deltaRatio = Math.min(prevDelta, currentDelta) /
+                Math.max(prevDelta, currentDelta);
+            if (inSpeedSection &&
+                (current.originalTapStrain < threeFingerStrainThreshold ||
+                    // Stop speed section on slowing down 1/2 rhythm change or anything slower.
+                    (prevDelta < currentDelta && deltaRatio <= 0.5) ||
+                    // Don't forget to manually add the last section, which would otherwise be ignored.
+                    i === this.objects.length - 1)) {
+                const lastSpeedObjectIndex = i - (i === this.objects.length - 1 ? 0 : 1);
+                inSpeedSection = false;
                 // Ignore sections that don't meet object count requirement.
-                if (i - firstObjectIndex < minSectionObjectCount) {
-                    firstObjectIndex = i + 1;
+                if (i - firstSpeedObjectIndex < minSectionObjectCount) {
                     continue;
                 }
-                tempSections.push({
-                    firstObjectIndex,
-                    lastObjectIndex: i,
-                });
-                firstObjectIndex = i + 1;
-            }
-        }
-        // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
-        if (this.objects.length - firstObjectIndex > minSectionObjectCount) {
-            tempSections.push({
-                firstObjectIndex,
-                lastObjectIndex: this.objects.length - 1,
-            });
-        }
-        // Refilter with tap strain in mind.
-        const { threeFingerStrainThreshold } = DroidDifficultyCalculator;
-        for (const section of tempSections) {
-            let inSpeedSection = false;
-            let newFirstObjectIndex = section.firstObjectIndex;
-            for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
-                const current = this.objects[i];
-                if (!inSpeedSection &&
-                    current.originalTapStrain >= threeFingerStrainThreshold) {
-                    inSpeedSection = true;
-                    newFirstObjectIndex = i;
-                    continue;
-                }
-                if (inSpeedSection &&
-                    current.originalTapStrain < threeFingerStrainThreshold) {
-                    inSpeedSection = false;
-                    // Ignore sections that don't meet object count requirement.
-                    if (i - newFirstObjectIndex < minSectionObjectCount) {
-                        continue;
-                    }
-                    this.attributes.possibleThreeFingeredSections.push({
-                        firstObjectIndex: newFirstObjectIndex,
-                        lastObjectIndex: i,
-                        sumStrain: this.calculateThreeFingerSummedStrain(newFirstObjectIndex, i),
-                    });
-                }
-            }
-            // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
-            // Ignore sections that don't meet object count requirement.
-            if (inSpeedSection &&
-                section.lastObjectIndex - newFirstObjectIndex >=
-                    minSectionObjectCount) {
                 this.attributes.possibleThreeFingeredSections.push({
-                    firstObjectIndex: newFirstObjectIndex,
-                    lastObjectIndex: section.lastObjectIndex,
-                    sumStrain: this.calculateThreeFingerSummedStrain(newFirstObjectIndex, section.lastObjectIndex),
+                    firstObjectIndex: firstSpeedObjectIndex,
+                    lastObjectIndex: lastSpeedObjectIndex,
+                    sumStrain: Math.pow(this.objects
+                        .slice(firstSpeedObjectIndex, lastSpeedObjectIndex + 1)
+                        .reduce((a, v) => a +
+                        v.originalTapStrain /
+                            threeFingerStrainThreshold, 0), 0.75),
                 });
             }
         }
-        if (maxStrain) {
-            this.attributes.speedNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
-            this.attributes.averageSpeedDeltaTime =
-                objectDeltaTimes.reduce((total, next, index) => total +
-                    (next * 1) /
-                        (1 +
-                            Math.exp(-((objectStrains[index] / maxStrain) *
-                                25 -
-                                20))), 0) /
-                    objectStrains.reduce((total, next) => total +
-                        1 / (1 + Math.exp(-((next / maxStrain) * 25 - 20))), 0);
-            this.attributes.tapDifficultStrainCount = objectStrains.reduce((total, next) => total + Math.pow(next / maxStrain, 4), 0);
-        }
-    }
-    /**
-     * Calculates the sum of strains for possible three-fingered sections.
-     *
-     * @param firstObjectIndex The index of the first object in the section.
-     * @param lastObjectIndex The index of the last object in the section.
-     * @returns The summed strain of the section.
-     */
-    calculateThreeFingerSummedStrain(firstObjectIndex, lastObjectIndex) {
-        return Math.pow(this.objects
-            .slice(firstObjectIndex, lastObjectIndex)
-            .reduce((a, v) => a +
-            v.originalTapStrain /
-                DroidDifficultyCalculator.threeFingerStrainThreshold, 0), 0.75);
     }
     /**
      * Called after rhythm skill calculation.
@@ -1906,12 +1948,9 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.attributes.flashlightDifficulty *= 0.7;
         }
-        const objectStrains = this.objects.map((v) => v.flashlightStrainWithSliders);
-        const maxStrain = Math.max(...objectStrains);
-        if (maxStrain) {
-            this.attributes.flashlightDifficultStrainCount =
-                objectStrains.reduce((total, next) => total + Math.pow(next / maxStrain, 4), 0);
-        }
+        this.attributes.flashlightDifficulty = this.flashlight;
+        this.attributes.flashlightDifficultStrainCount =
+            flashlightSkill.countDifficultStrains();
     }
     /**
      * Called after visual skill calculation.
@@ -1928,11 +1967,8 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
                 this.starValue(visualSkillWithoutSliders.difficultyValue()) /
                     this.visual;
         }
-        const objectStrains = this.objects.map((v) => v.flashlightStrainWithSliders);
-        const maxStrain = Math.max(...objectStrains);
-        if (maxStrain) {
-            this.attributes.visualDifficultStrainCount = objectStrains.reduce((total, next) => total + Math.pow(next / maxStrain, 4), 0);
-        }
+        this.attributes.visualDifficultStrainCount =
+            visualSkillWithSliders.countDifficultStrains();
     }
 }
 /**
@@ -2303,7 +2339,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     calculateAimValue() {
         let aimValue = this.baseValue(Math.pow(this.difficultyAttributes.aimDifficulty, 0.8));
-        aimValue *= this.proportionalMissPenalty;
+        aimValue *= Math.min(this.calculateStrainBasedMissPenalty(this.difficultyAttributes.aimDifficultStrainCount), this.proportionalMissPenalty);
         // Scale the aim value with estimated full combo deviation.
         aimValue *= this.calculateDeviationBasedLengthScaling();
         // Scale the aim value with slider factor to nerf very likely dropped sliderends.
@@ -2343,6 +2379,16 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         tapValue *=
             1.1 *
                 Math.pow(osuBase.ErrorFunction.erf(20 / (Math.SQRT2 * adjustedDeviation)), 0.625);
+        // 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.
+        // We harshen the punishment for such scenario.
+        tapValue *=
+            (1 - Math.pow(this.difficultyAttributes.vibroFactor, 6)) /
+                (1 +
+                    Math.exp((this._tapDeviation - 7500 / averageBPM) /
+                        ((2 * 300) / averageBPM))) +
+                Math.pow(this.difficultyAttributes.vibroFactor, 6);
         // Scale the tap value with three-fingered penalty.
         tapValue /= this._tapPenalty;
         // OD 8 SS stays the same.
@@ -2383,7 +2429,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return 0;
         }
         let flashlightValue = Math.pow(this.difficultyAttributes.flashlightDifficulty, 1.6) * 25;
-        flashlightValue *= this.proportionalMissPenalty;
+        flashlightValue *= Math.min(this.calculateStrainBasedMissPenalty(this.difficultyAttributes.flashlightDifficultStrainCount), this.proportionalMissPenalty);
         // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
         flashlightValue *=
             0.7 +
@@ -2402,7 +2448,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     calculateVisualValue() {
         let visualValue = Math.pow(this.difficultyAttributes.visualDifficulty, 1.6) * 22.5;
-        visualValue *= this.proportionalMissPenalty;
+        visualValue *= Math.min(this.calculateStrainBasedMissPenalty(this.difficultyAttributes.visualDifficultStrainCount), this.proportionalMissPenalty);
         // Scale the visual value with estimated full combo deviation.
         // As visual is easily "bypassable" with memorization, punish for memorization.
         visualValue *= this.calculateDeviationBasedLengthScaling(undefined, true);
@@ -2514,28 +2560,32 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (greatCountCircles > 0) {
             // The probability that a player hits a circle is unknown, but we can estimate it to be
             // the number of greats on circles divided by the number of circles, and then add one
-            // to the number of circles as a bias correction / bayesian prior.
-            const greatProbabilityCircle = Math.max(0, greatCountCircles / (greatCountCircles + okCountCircles + 1));
+            // to the number of circles as a bias correction.
+            const greatProbabilityCircle = greatCountCircles /
+                (circleCount - missCountCircles - mehCountCircles + 1);
             // Compute the deviation assuming 300s and 100s are normally distributed, and 50s are uniformly distributed.
             // Begin with the normal distribution first.
-            const deviationOnCircles = hitWindow300 /
+            let deviationOnCircles = hitWindow300 /
                 (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilityCircle));
-            // Get the variance of the truncated variable.
-            const truncatedVariance = Math.pow(deviationOnCircles, 2) -
+            deviationOnCircles *= Math.sqrt(1 -
                 (Math.sqrt(2 / Math.PI) *
                     hitWindow100 *
-                    deviationOnCircles *
-                    Math.exp(-0.5 * Math.pow(hitWindow100 / deviationOnCircles, 2))) /
-                    osuBase.ErrorFunction.erf(hitWindow100 / (Math.SQRT2 * deviationOnCircles));
+                    Math.exp(-0.5 *
+                        Math.pow(hitWindow100 / deviationOnCircles, 2))) /
+                    (deviationOnCircles *
+                        osuBase.ErrorFunction.erf(hitWindow100 /
+                            (Math.SQRT2 * deviationOnCircles))));
             // Then compute the variance for 50s.
-            const mehVariance = (Math.pow(hitWindow50, 2) +
+            const mehVariance = (hitWindow50 * hitWindow50 +
                 hitWindow100 * hitWindow50 +
-                Math.pow(hitWindow100, 2)) /
+                hitWindow100 * hitWindow100) /
                 3;
             // Find the total deviation.
-            return Math.sqrt(((greatCountCircles + okCountCircles) * truncatedVariance +
+            deviationOnCircles = Math.sqrt(((greatCountCircles + okCountCircles) *
+                Math.pow(deviationOnCircles, 2) +
                 mehCountCircles * mehVariance) /
                 (greatCountCircles + okCountCircles + mehCountCircles));
+            return deviationOnCircles;
         }
         // If there are more non-300s than there are circles, compute the deviation on sliders instead.
         // Here, all that matters is whether or not the slider was missed, since it is impossible
@@ -2562,23 +2612,59 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (this.totalSuccessfulHits === 0) {
             return Number.POSITIVE_INFINITY;
         }
-        const hitWindow300 = new osuBase.OsuHitWindow(this.difficultyAttributes.overallDifficulty).hitWindowFor300();
+        const { speedNoteCount, clockRate, overallDifficulty } = this.difficultyAttributes;
+        const hitWindow300 = new osuBase.OsuHitWindow(overallDifficulty).hitWindowFor300();
+        // Obtain the 50 and 100 hit window for droid.
+        const isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
+        const droidHitWindow = new osuBase.DroidHitWindow(osuBase.DroidHitWindow.hitWindow300ToOD(hitWindow300 * clockRate, isPrecise));
+        const hitWindow50 = droidHitWindow.hitWindowFor50(isPrecise) / clockRate;
+        const hitWindow100 = droidHitWindow.hitWindowFor100(isPrecise) / clockRate;
         const { n100, n50, nmiss } = this.computedAccuracy;
         // Assume a fixed ratio of non-300s hit in speed notes based on speed note count ratio and OD.
-        // Graph: https://www.desmos.com/calculator/31argjcxqc
-        const speedNoteRatio = this.difficultyAttributes.speedNoteCount / this.totalHits;
+        // Graph: https://www.desmos.com/calculator/iskvgjkxr4
+        const speedNoteRatio = speedNoteCount / this.totalHits;
         const nonGreatCount = n100 + n50 + nmiss;
         const nonGreatRatio = 1 -
             (Math.pow(Math.exp(Math.sqrt(hitWindow300)) + 1, 1 - speedNoteRatio) -
                 1) /
                 Math.exp(Math.sqrt(hitWindow300));
-        const relevantCountGreat = Math.max(0, this.difficultyAttributes.speedNoteCount -
-            nonGreatCount * nonGreatRatio);
-        if (relevantCountGreat === 0) {
-            return Number.POSITIVE_INFINITY;
+        const relevantCountGreat = Math.max(0, speedNoteCount - nonGreatCount * nonGreatRatio);
+        const relevantCountOk = n100 * nonGreatRatio;
+        const relevantCountMeh = n50 * nonGreatRatio;
+        const relevantCountMiss = nmiss * nonGreatRatio;
+        // Assume 100s, 50s, and misses happen on circles. If there are less non-300s on circles than 300s,
+        // compute the deviation on circles.
+        if (relevantCountGreat > 0) {
+            // The probability that a player hits a circle is unknown, but we can estimate it to be
+            // the number of greats on circles divided by the number of circles, and then add one
+            // to the number of circles as a bias correction.
+            const greatProbabilityCircle = relevantCountGreat /
+                (speedNoteCount - relevantCountMiss - relevantCountMeh + 1);
+            // Compute the deviation assuming 300s and 100s are normally distributed, and 50s are uniformly distributed.
+            // Begin with the normal distribution first.
+            let deviationOnCircles = hitWindow300 /
+                (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilityCircle));
+            deviationOnCircles *= Math.sqrt(1 -
+                (Math.sqrt(2 / Math.PI) *
+                    hitWindow100 *
+                    Math.exp(-0.5 *
+                        Math.pow(hitWindow100 / deviationOnCircles, 2))) /
+                    (deviationOnCircles *
+                        osuBase.ErrorFunction.erf(hitWindow100 /
+                            (Math.SQRT2 * deviationOnCircles))));
+            // Then compute the variance for 50s.
+            const mehVariance = (hitWindow50 * hitWindow50 +
+                hitWindow100 * hitWindow50 +
+                hitWindow100 * hitWindow100) /
+                3;
+            // Find the total deviation.
+            deviationOnCircles = Math.sqrt(((relevantCountGreat + relevantCountOk) *
+                Math.pow(deviationOnCircles, 2) +
+                relevantCountMeh * mehVariance) /
+                (relevantCountGreat + relevantCountOk + relevantCountMeh));
+            return deviationOnCircles;
         }
-        const greatProbability = relevantCountGreat / (this.difficultyAttributes.speedNoteCount + 1);
-        return (hitWindow300 / (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbability)));
+        return Number.POSITIVE_INFINITY;
     }
     toString() {
         return (this.total.toFixed(2) +
@@ -3138,7 +3224,7 @@ class OsuDifficultyHitObject extends DifficultyHitObject {
     }
     /**
      * 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.).
+     * 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.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.19",
+    "version": "4.0.0-beta.20",
     "description": "A module for calculating osu!standard beatmap difficulty and performance value with respect to the current difficulty and performance algorithm.",
     "keywords": [
         "osu",
@@ -38,5 +38,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "45f7c976ba683027dc3a4d29de8bf289aadf7707"
+    "gitHead": "8e6d7449a4a949f0158f10b9130378e7368bd8aa"
 }

package/typings/index.d.ts

@@ -204,16 +204,13 @@ declare abstract class DifficultyHitObject {
     private readonly lastLastObject;
     /**
      * 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.).
+     * 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.
-     * @param timePreempt The time preempt with clock rate.
-     * @param isForceAR Whether force AR is enabled.
-     * @param mode The gamemode to compute properties for.
      */
     protected constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number);
     /**
@@ -476,6 +473,13 @@ declare abstract class StrainSkill extends Skill {
      * @param ms The time frame to calculate.
      */
     protected strainDecay(ms: number): number;
+    /**
+     * Calculates the starting time of a strain section at an object.
+     *
+     * @param current The object at which the strain section starts.
+     * @returns The start time of the strain section.
+     */
+    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
     /**
      * Calculates the strain value at a hitobject.
      *
@@ -512,7 +516,27 @@ declare abstract class DroidSkill extends StrainSkill {
      * The bonus multiplier that is given for a sequence of notes of equal difficulty.
      */
     protected abstract readonly starsPerDouble: number;
+    protected readonly _objectStrains: number[];
+    /**
+     * The strains of hitobjects.
+     */
+    get objectStrains(): readonly number[];
+    /**
+     * Returns the number of strains weighed against the top strain.
+     *
+     * The result is scaled by clock rate as it affects the total number of strains.
+     */
+    countDifficultStrains(): number;
+    process(current: DifficultyHitObject): void;
     difficultyValue(): number;
+    /**
+     * Gets the strain of a hitobject.
+     *
+     * @param current The hitobject to get the strain from.
+     * @returns The strain of the hitobject.
+     */
+    protected abstract getObjectStrain(current: DifficultyHitObject): number;
+    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
 }
 
 /**
@@ -568,7 +592,7 @@ declare class DroidDifficultyHitObject extends DifficultyHitObject {
     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.).
+     * 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.
@@ -597,16 +621,17 @@ declare class DroidDifficultyHitObject extends DifficultyHitObject {
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 declare class DroidAim extends DroidSkill {
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly starsPerDouble: number;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly starsPerDouble = 1.05;
     private readonly skillMultiplier;
     private readonly withSliders;
     private currentAimStrain;
     constructor(mods: Mod[], withSliders: boolean);
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
     /**
      * @param current The hitobject to save to.
      */
@@ -617,9 +642,9 @@ declare class DroidAim extends DroidSkill {
  * An evaluator for calculating osu!droid Aim skill.
  */
 declare abstract class DroidAimEvaluator extends AimEvaluator {
-    protected static readonly wideAngleMultiplier: number;
-    protected static readonly sliderMultiplier: number;
-    protected static readonly velocityChangeMultiplier: number;
+    protected static readonly wideAngleMultiplier = 1.65;
+    protected static readonly sliderMultiplier = 1.5;
+    protected static readonly velocityChangeMultiplier = 0.85;
     private static readonly singleSpacingThreshold;
     private static readonly minSpeedBonus;
     /**
@@ -680,6 +705,14 @@ interface DroidDifficultyAttributes extends DifficultyAttributes {
      * The average delta time of speed objects.
      */
     averageSpeedDeltaTime: number;
+    /**
+     * Describes how much of tap difficulty is contributed by notes that are "vibroable".
+     *
+     * A value closer to 1 indicates most of tap difficulty is contributed by notes that are not "vibroable".
+     *
+     * A value closer to 0 indicates most of tap difficulty is contributed by notes that are "vibroable".
+     */
+    vibroFactor: number;
 }
 
 /**
@@ -785,7 +818,6 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidDiffic
     get cacheableAttributes(): CacheableDifficultyAttributes<DroidDifficultyAttributes>;
     protected readonly difficultyMultiplier = 0.18;
     protected readonly mode = Modes.droid;
-    calculate(options?: DroidDifficultyCalculationOptions): this;
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -827,20 +859,13 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidDiffic
      * Called after tap skill calculation.
      *
      * @param tapSkillCheese The tap skill that considers cheesing.
+     * @param tapSkillVibro The tap skill that considers vibro.
      */
     private postCalculateTap;
     /**
      * Calculates tap-related attributes.
      */
     private calculateTapAttributes;
-    /**
-     * Calculates the sum of strains for possible three-fingered sections.
-     *
-     * @param firstObjectIndex The index of the first object in the section.
-     * @param lastObjectIndex The index of the last object in the section.
-     * @returns The summed strain of the section.
-     */
-    private calculateThreeFingerSummedStrain;
     /**
      * Called after rhythm skill calculation.
      *
@@ -867,10 +892,10 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidDiffic
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 declare class DroidFlashlight extends DroidSkill {
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly starsPerDouble: number;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly starsPerDouble = 1.06;
     private readonly skillMultiplier;
     private readonly isHidden;
     private readonly withSliders;
@@ -878,6 +903,7 @@ declare class DroidFlashlight extends DroidSkill {
     constructor(mods: Mod[], withSliders: boolean);
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
+    protected getObjectStrain(): number;
     protected saveToHitObject(current: DroidDifficultyHitObject): void;
     difficultyValue(): number;
 }
@@ -1099,7 +1125,7 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator<DroidDiff
      */
     get visualSliderCheesePenalty(): number;
     protected finalMultiplier: number;
-    protected readonly mode: Modes;
+    protected readonly mode = Modes.droid;
     private _aimSliderCheesePenalty;
     private _flashlightSliderCheesePenalty;
     private _visualSliderCheesePenalty;
@@ -1211,16 +1237,17 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator<DroidDiff
  * Represents the skill required to properly follow a beatmap's rhythm.
  */
 declare class DroidRhythm extends DroidSkill {
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly strainDecayBase: number;
-    protected readonly starsPerDouble: number;
+    protected readonly reducedSectionCount = 5;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly strainDecayBase = 0.3;
+    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;
     protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
@@ -1252,18 +1279,33 @@ declare abstract class DroidRhythmEvaluator 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.
  */
 declare class DroidTap extends DroidSkill {
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly strainDecayBase: number;
-    protected readonly starsPerDouble: number;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly strainDecayBase = 0.3;
+    protected readonly starsPerDouble = 1.1;
     private currentTapStrain;
     private currentRhythmMultiplier;
     private readonly skillMultiplier;
     private readonly greatWindow;
     private readonly considerCheesability;
-    constructor(mods: Mod[], overallDifficulty: number, considerCheesability: boolean);
+    private readonly strainTimeCap?;
+    private readonly _objectDeltaTimes;
+    /**
+     * The delta time of hitobjects.
+     */
+    get objectDeltaTimes(): readonly number[];
+    constructor(mods: Mod[], overallDifficulty: number, considerCheesability: boolean, strainTimeCap?: number);
+    /**
+     * The amount of notes that are relevant to the difficulty.
+     */
+    relevantNoteCount(): number;
+    /**
+     * The delta time relevant to the difficulty.
+     */
+    relevantDeltaTime(): number;
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
     /**
      * @param current The hitobject to save to.
      */
@@ -1288,23 +1330,25 @@ declare abstract class DroidTapEvaluator extends SpeedEvaluator {
      *
      * - time between pressing the previous and current object,
      * - distance between those objects,
-     * - and how easily they can be cheesed.
+     * - how easily they can be cheesed,
+     * - and the strain time cap.
      *
      * @param current The current object.
      * @param greatWindow The great hit window of the current object.
      * @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): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, greatWindow: number, considerCheesability: boolean, strainTimeCap?: number): number;
 }
 
 /**
  * Represents the skill required to read every object in the map.
  */
 declare class DroidVisual extends DroidSkill {
-    protected readonly starsPerDouble: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly strainDecayBase: number;
+    protected readonly starsPerDouble = 1.025;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly strainDecayBase = 0.1;
     private readonly isHidden;
     private readonly withSliders;
     private currentVisualStrain;
@@ -1313,11 +1357,12 @@ declare class DroidVisual extends DroidSkill {
     constructor(mods: Mod[], withSliders: boolean);
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
     protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
 /**
- * An evaluator for calculating osu!droid Visual skill.
+ * An evaluator for calculating osu!droid visual skill.
  */
 declare abstract class DroidVisualEvaluator {
     /**
@@ -1377,7 +1422,7 @@ declare class OsuDifficultyHitObject extends DifficultyHitObject {
     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.).
+     * 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.