@rian8337/osu-difficulty-calculator 4.0.0-beta.1 → 4.0.0-beta.10

package/dist/index.js

@@ -207,10 +207,9 @@ class DifficultyHitObject {
      *
      * @param time The time to calculate the hitobject's opacity at.
      * @param isHidden Whether Hidden mod is used.
-     * @param mode The gamemode to calculate the opacity for.
      * @returns The opacity of the hitobject at the given time.
      */
-    opacityAt(time, isHidden, mode) {
+    opacityAt(time, isHidden) {
         if (time > this.object.startTime) {
             // Consider a hitobject as being invisible when its start time is passed.
             // In reality the hitobject will be visible beyond its start time up until its hittable window has passed,
@@ -221,10 +220,7 @@ class DifficultyHitObject {
         const fadeInDuration = this.timeFadeIn;
         if (isHidden) {
             const fadeOutStartTime = fadeInStartTime + fadeInDuration;
-            const fadeOutDuration = this.baseTimePreempt *
-                (mode === osuBase.Modes.droid
-                    ? 0.35
-                    : osuBase.ModHidden.fadeOutDurationMultiplier);
+            const fadeOutDuration = this.baseTimePreempt * osuBase.ModHidden.fadeOutDurationMultiplier;
             return Math.min(osuBase.MathUtils.clamp((time - fadeInStartTime) / fadeInDuration, 0, 1), 1 -
                 osuBase.MathUtils.clamp((time - fadeOutStartTime) / fadeOutDuration, 0, 1));
         }
@@ -297,34 +293,16 @@ class DifficultyHitObjectCreator {
         if (this.mode === osuBase.Modes.droid) {
             this.maximumSliderRadius = this.normalizedRadius * 2;
         }
-        const droidCircleSize = new osuBase.MapStats({
-            cs: params.circleSize,
-            mods: params.mods,
-        }).calculate({ mode: osuBase.Modes.droid }).cs;
-        const droidScale = (1 - (0.7 * (droidCircleSize - 5)) / 5) / 2;
-        const osuCircleSize = new osuBase.MapStats({
-            cs: params.circleSize,
-            mods: params.mods,
-        }).calculate({ mode: osuBase.Modes.osu }).cs;
-        const osuScale = (1 - (0.7 * (osuCircleSize - 5)) / 5) / 2;
-        params.objects[0].droidScale = droidScale;
-        params.objects[0].osuScale = osuScale;
         const scalingFactor = this.getScalingFactor(params.objects[0].getRadius(this.mode));
         const difficultyObjects = [];
         for (let i = 0; i < params.objects.length; ++i) {
             const object = new DifficultyHitObject(params.objects[i], difficultyObjects);
             object.index = difficultyObjects.length - 1;
-            object.object.droidScale = droidScale;
-            object.object.osuScale = osuScale;
             object.timePreempt = params.preempt;
             object.baseTimePreempt = params.preempt * params.speedMultiplier;
             if (object.object instanceof osuBase.Slider) {
                 object.velocity =
                     object.object.velocity * params.speedMultiplier;
-                object.object.nestedHitObjects.forEach((o) => {
-                    o.droidScale = droidScale;
-                    o.osuScale = osuScale;
-                });
                 this.calculateSliderCursorPosition(object.object);
                 object.travelDistance = object.object.lazyTravelDistance;
                 // Bonus for repeat sliders until a better per nested object strain system can be achieved.
@@ -367,9 +345,6 @@ class DifficultyHitObjectCreator {
                     object.endTime + object.timePreempt) {
                     break;
                 }
-                // Future objects do not have their scales set, so we set them here.
-                o.droidScale = droidScale;
-                o.osuScale = osuScale;
                 nextVisibleObjects.push(o);
             }
             for (let j = 0; j < object.index; ++j) {
@@ -620,7 +595,6 @@ class DifficultyCalculator {
         speed: [],
         flashlight: [],
     };
-    sectionLength = 400;
     /**
      * Constructs a new instance of the calculator.
      *
@@ -655,6 +629,7 @@ class DifficultyCalculator {
             speedMultiplier: options?.stats?.speedMultiplier,
             oldStatistics: options?.stats?.oldStatistics,
         }).calculate({ mode: this.mode });
+        this.preProcess();
         this.populateDifficultyAttributes();
         this.generateDifficultyHitObjects();
         this.calculateAll();
@@ -674,6 +649,11 @@ class DifficultyCalculator {
             preempt: osuBase.MapStats.arToMS(this.stats.ar),
         }));
     }
+    /**
+     * Performs some pre-processing before proceeding with difficulty calculation.
+     */
+    preProcess() {
+    }
     /**
      * Calculates the skills provided.
      *
@@ -702,6 +682,7 @@ class DifficultyCalculator {
         this.attributes.overallDifficulty = this.stats.od;
         this.attributes.sliderCount = this.beatmap.hitObjects.sliders;
         this.attributes.spinnerCount = this.beatmap.hitObjects.spinners;
+        this.attributes.clockRate = this.stats.speedMultiplier;
     }
     /**
      * Calculates the star rating value of a difficulty.
@@ -861,7 +842,8 @@ class DroidAimEvaluator extends AimEvaluator {
             velocityChangeBonus * this.velocityChangeMultiplier);
         // Add in additional slider velocity bonus.
         if (withSliders) {
-            strain += sliderBonus * this.sliderMultiplier;
+            strain +=
+                Math.pow(1 + sliderBonus * this.sliderMultiplier, 1.25) - 1;
         }
         return strain;
     }
@@ -918,7 +900,6 @@ class StrainSkill extends Skill {
     strainPeaks = [];
     sectionLength = 400;
     currentSectionEnd = 0;
-    isFirstObject = true;
     /**
      * Calculates the strain value of a hitobject and stores the value in it. This value is affected by previously processed objects.
      *
@@ -926,11 +907,10 @@ class StrainSkill extends Skill {
      */
     process(current) {
         // The first object doesn't generate a strain, so we begin with an incremented section end
-        if (this.isFirstObject) {
+        if (current.index === 0) {
             this.currentSectionEnd =
                 Math.ceil(current.startTime / this.sectionLength) *
                     this.sectionLength;
-            this.isFirstObject = false;
         }
         while (current.startTime > this.currentSectionEnd) {
             this.saveCurrentPeak();
@@ -1065,7 +1045,6 @@ class DroidTapEvaluator extends SpeedEvaluator {
             current.isOverlapping(false)) {
             return 0;
         }
-        let strainTime = current.strainTime;
         let doubletapness = 1;
         if (considerCheesability) {
             const greatWindowFull = greatWindow * 2;
@@ -1080,16 +1059,14 @@ class DroidTapEvaluator extends SpeedEvaluator {
                 const windowRatio = Math.pow(Math.min(1, currentDeltaTime / greatWindowFull), 2);
                 doubletapness = Math.pow(speedRatio, 1 - windowRatio);
             }
-            // Cap deltatime to the OD 300 hitwindow.
-            // 0.58 is derived from making sure 260 BPM 1/4 OD5 streams aren't nerfed harshly, whilst 0.91 limits the effect of the cap.
-            strainTime /= osuBase.MathUtils.clamp(strainTime / greatWindowFull / 0.58, 0.91, 1);
         }
         let speedBonus = 1;
-        if (strainTime < this.minSpeedBonus) {
+        if (current.strainTime < this.minSpeedBonus) {
             speedBonus +=
-                0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
+                0.75 *
+                    Math.pow(osuBase.ErrorFunction.erf((this.minSpeedBonus - current.strainTime) / 40), 2);
         }
-        return (speedBonus * doubletapness) / strainTime;
+        return (speedBonus * Math.pow(doubletapness, 1.5)) / current.strainTime;
     }
 }
 
@@ -1193,7 +1170,7 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
                 const opacityBonus = 1 +
                     this.maxOpacityBonus *
                         (1 -
-                            current.opacityAt(currentObject.object.startTime, isHiddenMod, osuBase.Modes.droid));
+                            current.opacityAt(currentObject.object.startTime, isHiddenMod));
                 result +=
                     (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
                         cumulativeStrainTime;
@@ -1236,11 +1213,11 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 class DroidFlashlight extends DroidSkill {
-    skillMultiplier = 0.125;
+    skillMultiplier = 0.052;
     strainDecayBase = 0.15;
     reducedSectionCount = 0;
     reducedSectionBaseline = 1;
-    starsPerDouble = 1.05;
+    starsPerDouble = 1.06;
     isHidden;
     withSliders;
     constructor(mods, withSliders) {
@@ -1265,6 +1242,9 @@ class DroidFlashlight extends DroidSkill {
             current.flashlightStrainWithoutSliders = this.currentStrain;
         }
     }
+    difficultyValue() {
+        return Math.pow(this.strainPeaks.reduce((a, v) => a + v, 0) * this.starsPerDouble, 0.8);
+    }
 }
 
 /**
@@ -1456,7 +1436,8 @@ class DroidVisualEvaluator {
     static evaluateDifficultyOf(current, isHiddenMod, withSliders) {
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
-            current.isOverlapping(true)) {
+            current.isOverlapping(true) ||
+            current.index === 0) {
             return 0;
         }
         // Start with base density and give global bonus for Hidden.
@@ -1483,7 +1464,7 @@ class DroidVisualEvaluator {
             }
             strain +=
                 (1 -
-                    current.opacityAt(previous.object.startTime, isHiddenMod, osuBase.Modes.droid)) /
+                    current.opacityAt(previous.object.startTime, isHiddenMod)) /
                     4;
         }
         // Scale the value with overlapping factor.
@@ -1519,44 +1500,6 @@ class DroidVisualEvaluator {
                         Math.min(1, 300 / cumulativeStrainTime);
             }
         }
-        // Reward for rhythm changes.
-        if (current.rhythmMultiplier > 1) {
-            let rhythmBonus = (current.rhythmMultiplier - 1) / 20;
-            // Rhythm changes are harder to read in Hidden.
-            // Add additional bonus for Hidden.
-            if (isHiddenMod) {
-                rhythmBonus += (current.rhythmMultiplier - 1) / 25;
-            }
-            // Rhythm changes are harder to read when objects are stacked together.
-            // Scale rhythm bonus based on the stack of past objects.
-            const diameter = 2 * current.object.getRadius(osuBase.Modes.droid);
-            let cumulativeStrainTime = 0;
-            for (let i = 0; i < Math.min(current.index, 5); ++i) {
-                const previous = current.previous(i);
-                if (previous.object instanceof osuBase.Spinner ||
-                    // Exclude overlapping objects that can be tapped at once.
-                    previous.isOverlapping(true)) {
-                    continue;
-                }
-                const jumpDistance = current.object
-                    .getStackedPosition(osuBase.Modes.droid)
-                    .getDistance(previous.object.getStackedEndPosition(osuBase.Modes.droid));
-                cumulativeStrainTime += previous.strainTime;
-                rhythmBonus +=
-                    // Scale the bonus with diameter.
-                    osuBase.MathUtils.clamp((0.5 - jumpDistance / diameter) / 10, 0, 0.05) *
-                        // Scale with cumulative strain time to avoid overbuffing past objects.
-                        Math.min(1, 300 / cumulativeStrainTime);
-                // Give a larger bonus for Hidden.
-                if (isHiddenMod) {
-                    rhythmBonus +=
-                        (1 -
-                            current.opacityAt(previous.object.startTime, isHiddenMod, osuBase.Modes.droid)) /
-                            20;
-                }
-            }
-            strain += rhythmBonus;
-        }
         return strain;
     }
 }
@@ -1571,20 +1514,20 @@ class DroidVisual extends DroidSkill {
     skillMultiplier = 10;
     strainDecayBase = 0.1;
     isHidden;
-    withSliders;
+    withsliders;
     constructor(mods, withSliders) {
         super(mods);
         this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
-        this.withSliders = withSliders;
+        this.withsliders = withSliders;
     }
     strainValueAt(current) {
         this.currentStrain *= this.strainDecay(current.deltaTime);
         this.currentStrain +=
-            DroidVisualEvaluator.evaluateDifficultyOf(current, this.isHidden, this.withSliders) * this.skillMultiplier;
-        return this.currentStrain;
+            DroidVisualEvaluator.evaluateDifficultyOf(current, this.isHidden, this.withsliders) * this.skillMultiplier;
+        return this.currentStrain * (1 + (current.rhythmMultiplier - 1) / 5);
     }
     saveToHitObject(current) {
-        if (this.withSliders) {
+        if (this.withsliders) {
             current.visualStrainWithSliders = this.currentStrain;
         }
         else {
@@ -1635,15 +1578,21 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         flashlightDifficulty: 0,
         speedNoteCount: 0,
         sliderFactor: 0,
+        clockRate: 1,
         approachRate: 0,
         overallDifficulty: 0,
         hitCircleCount: 0,
         sliderCount: 0,
         spinnerCount: 0,
+        aimDifficultStrainCount: 0,
+        tapDifficultStrainCount: 0,
+        flashlightDifficultStrainCount: 0,
+        visualDifficultStrainCount: 0,
         flashlightSliderFactor: 0,
         visualSliderFactor: 0,
         possibleThreeFingeredSections: [],
         difficultSliders: [],
+        averageSpeedDeltaTime: 0,
     };
     difficultyMultiplier = 0.18;
     mode = osuBase.Modes.droid;
@@ -1765,9 +1714,6 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         }
         this.calculateTotal();
     }
-    /**
-     * Returns a string representative of the class.
-     */
     toString() {
         return (this.total.toFixed(2) +
             " stars (" +
@@ -1782,9 +1728,13 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             this.visual.toFixed(2) +
             " visual)");
     }
-    /**
-     * Creates skills to be calculated.
-     */
+    preProcess() {
+        const scale = osuBase.CircleSizeCalculator.standardCSToStandardScale(this.stats.cs);
+        for (const object of this.beatmap.hitObjects.objects) {
+            object.droidScale = scale;
+        }
+        osuBase.HitObjectStackEvaluator.applyDroidStacking(this.beatmap.hitObjects.objects, this.beatmap.general.stackLeniency);
+    }
     createSkills() {
         return [
             new DroidAim(this.mods, true),
@@ -1825,7 +1775,6 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     calculateAimAttributes() {
         const objectStrains = [];
         let maxStrain = 0;
-        // Take the top 15% most difficult sliders based on velocity.
         const topDifficultSliders = [];
         for (let i = 0; i < this.objects.length; ++i) {
             const object = this.objects[i];
@@ -1837,22 +1786,28 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
                     index: i,
                     velocity: velocity,
                 });
-                topDifficultSliders.sort((a, b) => b.velocity - a.velocity);
-                while (topDifficultSliders.length >
-                    Math.ceil(0.15 * this.beatmap.hitObjects.sliders)) {
-                    topDifficultSliders.pop();
-                }
             }
         }
         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) {
-            this.attributes.difficultSliders.push({
-                index: slider.index,
-                difficultyRating: slider.velocity / velocitySum,
-            });
+            const difficultyRating = slider.velocity / velocitySum;
+            // Only consider sliders that are fast enough.
+            if (difficultyRating > 0.02) {
+                this.attributes.difficultSliders.push({
+                    index: slider.index,
+                    difficultyRating: slider.velocity / velocitySum,
+                });
+            }
+        }
+        this.attributes.difficultSliders.sort((a, b) => b.difficultyRating - a.difficultyRating);
+        // Take the top 15% most difficult sliders.
+        while (this.attributes.difficultSliders.length >
+            Math.ceil(0.15 * this.beatmap.hitObjects.sliders)) {
+            this.attributes.difficultSliders.pop();
         }
     }
     /**
@@ -1871,6 +1826,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         this.attributes.possibleThreeFingeredSections = [];
         const tempSections = [];
         const objectStrains = [];
+        const objectDeltaTimes = [];
         let maxStrain = 0;
         const maxSectionDeltaTime = 2000;
         const minSectionObjectCount = 5;
@@ -1880,8 +1836,10 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             const next = this.objects[i + 1];
             if (i === 0) {
                 objectStrains.push(current.tapStrain);
+                objectDeltaTimes.push(current.deltaTime);
             }
             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) {
@@ -1920,6 +1878,10 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
                 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,
@@ -1928,7 +1890,10 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
                 }
             }
             // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
-            if (inSpeedSection) {
+            // Ignore sections that don't meet object count requirement.
+            if (inSpeedSection &&
+                section.lastObjectIndex - newFirstObjectIndex >=
+                    minSectionObjectCount) {
                 this.attributes.possibleThreeFingeredSections.push({
                     firstObjectIndex: newFirstObjectIndex,
                     lastObjectIndex: section.lastObjectIndex,
@@ -1938,6 +1903,16 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         }
         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);
         }
     }
     /**
@@ -1980,6 +1955,12 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.flashlight *= 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;
     }
     /**
@@ -1997,6 +1978,11 @@ 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);
+        }
     }
 }
 
@@ -2119,7 +2105,7 @@ class PerformanceCalculator {
         if (this.difficultyAttributes.sliderCount > 0) {
             // We assume 15% of sliders in a beatmap are difficult since there's no way to tell from the performance calculator.
             const estimateDifficultSliders = this.difficultyAttributes.sliderCount * 0.15;
-            const estimateSliderEndsDropped = osuBase.MathUtils.clamp(Math.min(this.computedAccuracy.n300 +
+            const estimateSliderEndsDropped = osuBase.MathUtils.clamp(Math.min(this.computedAccuracy.n100 +
                 this.computedAccuracy.n50 +
                 this.computedAccuracy.nmiss, maxCombo - combo), 0, estimateDifficultSliders);
             this.sliderNerfFactor =
@@ -2256,11 +2242,11 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      *
      * The aim and total performance value will be recalculated afterwards.
      *
-     * @param value The slider cheese penalty value. Must be between than 0 (exclusive) and 1 (inclusive).
+     * @param value The slider cheese penalty value. Must be between than 0 and 1.
      */
     applyAimSliderCheesePenalty(value) {
-        if (value <= 0) {
-            throw new RangeError("New aim slider cheese penalty must be greater than zero.");
+        if (value < 0) {
+            throw new RangeError("New aim slider cheese penalty must be greater than or equal to zero.");
         }
         if (value > 1) {
             throw new RangeError("New aim slider cheese penalty must be less than or equal to one.");
@@ -2268,8 +2254,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (value === this._aimSliderCheesePenalty) {
             return;
         }
-        this.aim *= value / this._aimSliderCheesePenalty;
         this._aimSliderCheesePenalty = value;
+        this.calculateAimValue();
         this.calculateTotalValue();
     }
     /**
@@ -2277,11 +2263,11 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      *
      * The flashlight and total performance value will be recalculated afterwards.
      *
-     * @param value The slider cheese penalty value. Must be between 0 (exclusive) and 1 (inclusive).
+     * @param value The slider cheese penalty value. Must be between 0 and 1.
      */
     applyFlashlightSliderCheesePenalty(value) {
-        if (value <= 0) {
-            throw new RangeError("New flashlight slider cheese penalty must be greater than zero.");
+        if (value < 0) {
+            throw new RangeError("New flashlight slider cheese penalty must be greater than or equal to zero.");
         }
         if (value > 1) {
             throw new RangeError("New flashlight slider cheese penalty must be less than or equal to one.");
@@ -2289,8 +2275,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (value === this._flashlightSliderCheesePenalty) {
             return;
         }
-        this.flashlight *= value / this._flashlightSliderCheesePenalty;
         this._flashlightSliderCheesePenalty = value;
+        this.calculateFlashlightValue();
         this.calculateTotalValue();
     }
     /**
@@ -2298,11 +2284,11 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      *
      * The visual and total performance value will be recalculated afterwards.
      *
-     * @param value The slider cheese penalty value. Must be between 0 (exclusive) and 1 (inclusive).
+     * @param value The slider cheese penalty value. Must be between 0 and 1.
      */
     applyVisualSliderCheesePenalty(value) {
-        if (value <= 0) {
-            throw new RangeError("New visual slider cheese penalty must be greater than zero.");
+        if (value < 0) {
+            throw new RangeError("New visual slider cheese penalty must be greater than or equal to zero.");
         }
         if (value > 1) {
             throw new RangeError("New visual slider cheese penalty must be less than or equal to one.");
@@ -2310,8 +2296,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (value === this._visualSliderCheesePenalty) {
             return;
         }
-        this.visual *= value / this._visualSliderCheesePenalty;
         this._visualSliderCheesePenalty = value;
+        this.calculateVisualValue();
         this.calculateTotalValue();
     }
     calculateValues() {
@@ -2345,16 +2331,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     calculateAimValue() {
         this.aim = this.baseValue(Math.pow(this.difficultyAttributes.aimDifficulty, 0.8));
-        if (this.effectiveMissCount > 0) {
-            // Penalize misses by assessing # of misses relative to the total # of objects.
-            // Default a 3% reduction for any # of misses.
-            this.aim *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
-        }
-        // Combo scaling
-        this.aim *= this.comboPenalty;
+        this.aim *= this.calculateMissPenalty(this.difficultyAttributes.aimDifficultStrainCount);
         // Scale the aim value with slider factor to nerf very likely dropped sliderends.
         this.aim *= this.sliderNerfFactor;
         // Scale the aim value with slider cheese penalty.
@@ -2369,20 +2346,23 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     calculateTapValue() {
         this.tap = this.baseValue(this.difficultyAttributes.tapDifficulty);
-        if (this.effectiveMissCount > 0) {
-            // Penalize misses by assessing # of misses relative to the total # of objects.
-            // Default a 3% reduction for any # of misses.
-            this.tap *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
-        }
-        // Combo scaling
-        this.tap *= this.comboPenalty;
+        this.tap *= this.calculateMissPenalty(this.difficultyAttributes.tapDifficultStrainCount);
+        // Normalize the deviation to 300 BPM.
+        const normalizedDeviation = this.tapDeviation *
+            Math.max(1, 50 / this.difficultyAttributes.averageSpeedDeltaTime);
+        // We expect the player to get 7500/x deviation when doubletapping x BPM.
+        // Using this expectation, we penalize scores with deviation above 25.
+        const averageBPM = 60000 / 4 / this.difficultyAttributes.averageSpeedDeltaTime;
+        const adjustedDeviation = normalizedDeviation *
+            (1 +
+                1 /
+                    (1 +
+                        Math.exp(-(normalizedDeviation - 7500 / averageBPM) /
+                            ((2 * 300) / averageBPM))));
         // Scale the tap value with tap deviation.
         this.tap *=
             1.1 *
-                Math.pow(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._tapDeviation)), 1.25);
+                Math.pow(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * adjustedDeviation)), 1.25);
         // Scale the tap value with three-fingered penalty.
         this.tap /= this._tapPenalty;
     }
@@ -2397,7 +2377,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         }
         this.accuracy =
             650 *
-                Math.exp(-0.125 * this._deviation) *
+                Math.exp(-0.1 * this._deviation) *
                 // The following function is to give higher reward for deviations lower than 25 (250 UR).
                 (15 / (this._deviation + 15) + 0.65);
         // Bonus for many hitcircles - it's harder to keep good accuracy up for longer.
@@ -2424,15 +2404,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         }
         this.flashlight =
             Math.pow(this.difficultyAttributes.flashlightDifficulty, 1.6) * 25;
-        // Combo scaling
-        this.flashlight *= this.comboPenalty;
-        if (this.effectiveMissCount > 0) {
-            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
-            this.flashlight *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
-        }
+        this.flashlight *= this.calculateMissPenalty(this.difficultyAttributes.flashlightDifficultStrainCount);
         // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
         this.flashlight *=
             0.7 +
@@ -2451,15 +2423,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
     calculateVisualValue() {
         this.visual =
             Math.pow(this.difficultyAttributes.visualDifficulty, 1.6) * 22.5;
-        if (this.effectiveMissCount > 0) {
-            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
-            this.visual *=
-                0.97 *
-                    Math.pow(1 -
-                        Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
-        }
-        // Combo scaling
-        this.visual *= this.comboPenalty;
+        this.visual *= this.calculateMissPenalty(this.difficultyAttributes.visualDifficultStrainCount);
         // Scale the visual value with object count to penalize short maps.
         this.visual *= Math.min(1, 1.650668 +
             (0.4845796 - 1.650668) /
@@ -2471,6 +2435,21 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             1.065 *
                 Math.pow(osuBase.ErrorFunction.erf(30 / (Math.SQRT2 * this._deviation)), 1.75);
     }
+    /**
+     * Calculates miss penalty.
+     *
+     * Miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    calculateMissPenalty(difficultStrainCount) {
+        if (this.effectiveMissCount === 0) {
+            return 1;
+        }
+        return (0.94 /
+            (this.effectiveMissCount / (2 * Math.sqrt(difficultStrainCount)) +
+                1));
+    }
     /**
      * Estimates the player's tap deviation based on the OD, number of circles and sliders,
      * and number of 300s, 100s, 50s, and misses, assuming the player's mean hit error is 0.
@@ -2490,17 +2469,16 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return Number.POSITIVE_INFINITY;
         }
         const hitWindow300 = new osuBase.OsuHitWindow(this.difficultyAttributes.overallDifficulty).hitWindowFor300();
-        // Obtain the 50 hit window for droid.
-        const clockRate = new osuBase.MapStats({
-            mods: this.difficultyAttributes.mods,
-        }).calculate().speedMultiplier;
-        const realHitWindow300 = hitWindow300 * clockRate;
+        // Obtain the 50 and 100 hit window for droid.
+        const realHitWindow300 = hitWindow300 * this.difficultyAttributes.clockRate;
         const droidHitWindow = new osuBase.DroidHitWindow(osuBase.OsuHitWindow.hitWindow300ToOD(realHitWindow300));
-        const hitWindow50 = droidHitWindow.hitWindowFor50(this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise)) / clockRate;
-        const greatCountOnCircles = this.difficultyAttributes.hitCircleCount -
-            this.computedAccuracy.n100 -
-            this.computedAccuracy.n50 -
-            this.computedAccuracy.nmiss;
+        const isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
+        const hitWindow50 = droidHitWindow.hitWindowFor50(isPrecise) /
+            this.difficultyAttributes.clockRate;
+        const hitWindow100 = droidHitWindow.hitWindowFor100(isPrecise) /
+            this.difficultyAttributes.clockRate;
+        const { n300, n100, n50, nmiss } = this.computedAccuracy;
+        const greatCountOnCircles = this.difficultyAttributes.hitCircleCount - n100 - n50 - nmiss;
         // 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.
@@ -2519,10 +2497,32 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (greatProbabilityCircle === 0 && greatProbabilitySlider === 0) {
             return Number.POSITIVE_INFINITY;
         }
-        const deviationOnCircles = hitWindow300 /
-            (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilityCircle));
-        const deviationOnSliders = hitWindow50 /
-            (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilitySlider));
+        const calculateDeviation = (mainHitWindow, probability) => {
+            if (probability === 0) {
+                return Number.POSITIVE_INFINITY;
+            }
+            // Start with normal deviation.
+            const normalDeviation = mainHitWindow /
+                (Math.SQRT2 * osuBase.ErrorFunction.erfInv(probability));
+            // Get the variance of the truncated variable.
+            const truncatedVariance = Math.pow(normalDeviation, 2) -
+                (Math.SQRT2 *
+                    hitWindow100 *
+                    normalDeviation *
+                    Math.exp(-0.5 * Math.pow(hitWindow100 / normalDeviation, 2))) /
+                    (Math.sqrt(Math.PI) *
+                        osuBase.ErrorFunction.erf(hitWindow100 / (Math.SQRT2 * normalDeviation)));
+            // Add 50s by assuming they are uniformly distributed.
+            return Math.sqrt((1 / (n300 + n100 + n50)) *
+                ((n300 + n100) * truncatedVariance +
+                    (n50 *
+                        (Math.pow(hitWindow50, 2) +
+                            hitWindow100 * hitWindow50 +
+                            Math.pow(hitWindow100, 2))) /
+                        3));
+        };
+        const deviationOnCircles = calculateDeviation(hitWindow300, greatProbabilityCircle);
+        const deviationOnSliders = calculateDeviation(hitWindow50, greatProbabilitySlider);
         return Math.min(deviationOnCircles, deviationOnSliders);
     }
     /**
@@ -2536,13 +2536,48 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return Number.POSITIVE_INFINITY;
         }
         const hitWindow300 = new osuBase.OsuHitWindow(this.difficultyAttributes.overallDifficulty).hitWindowFor300();
-        const relevantTotalDiff = this.totalHits - this.difficultyAttributes.speedNoteCount;
-        const relevantCountGreat = Math.max(0, this.computedAccuracy.n300 - relevantTotalDiff);
+        // Obtain the 50 and 100 hit window for droid.
+        const realHitWindow300 = hitWindow300 * this.difficultyAttributes.clockRate;
+        const droidHitWindow = new osuBase.DroidHitWindow(osuBase.OsuHitWindow.hitWindow300ToOD(realHitWindow300));
+        const isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
+        const hitWindow50 = droidHitWindow.hitWindowFor50(isPrecise) /
+            this.difficultyAttributes.clockRate;
+        const hitWindow100 = droidHitWindow.hitWindowFor100(isPrecise) /
+            this.difficultyAttributes.clockRate;
+        const { n300, 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;
+        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 greatProbability = relevantCountGreat / (this.difficultyAttributes.speedNoteCount + 1);
-        return (hitWindow300 / (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbability)));
+        // Start with normal deviation.
+        const normalDeviation = hitWindow300 /
+            (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbability));
+        // Get the variance of the truncated variable.
+        const truncatedVariance = Math.pow(normalDeviation, 2) -
+            (Math.SQRT2 *
+                hitWindow100 *
+                normalDeviation *
+                Math.exp(-0.5 * Math.pow(hitWindow100 / normalDeviation, 2))) /
+                (Math.sqrt(Math.PI) *
+                    osuBase.ErrorFunction.erf(hitWindow100 / (Math.SQRT2 * normalDeviation)));
+        // Add 50s by assuming they are uniformly distributed.
+        return Math.sqrt((1 / (n300 + n100 + n50)) *
+            ((n300 + n100) * truncatedVariance +
+                (n50 *
+                    (Math.pow(hitWindow50, 2) +
+                        hitWindow100 * hitWindow50 +
+                        Math.pow(hitWindow100, 2))) /
+                    3));
     }
     toString() {
         return (this.total.toFixed(2) +
@@ -3006,7 +3041,7 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
                 const opacityBonus = 1 +
                     this.maxOpacityBonus *
                         (1 -
-                            current.opacityAt(currentObject.object.startTime, isHiddenMod, osuBase.Modes.osu));
+                            current.opacityAt(currentObject.object.startTime, isHiddenMod));
                 result +=
                     (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
                         cumulativeStrainTime;
@@ -3098,6 +3133,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         flashlightDifficulty: 0,
         speedNoteCount: 0,
         sliderFactor: 0,
+        clockRate: 1,
         approachRate: 0,
         overallDifficulty: 0,
         hitCircleCount: 0,
@@ -3178,9 +3214,6 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         this.postCalculateFlashlight(flashlightSkill);
         this.calculateTotal();
     }
-    /**
-     * Returns a string representative of the class.
-     */
     toString() {
         return (this.total.toFixed(2) +
             " stars (" +
@@ -3191,9 +3224,17 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
             this.flashlight.toFixed(2) +
             " flashlight)");
     }
-    /**
-     * Creates skills to be calculated.
-     */
+    preProcess() {
+        const scale = osuBase.CircleSizeCalculator.standardCSToStandardScale(this.stats.cs);
+        for (const object of this.beatmap.hitObjects.objects) {
+            object.osuScale = scale;
+        }
+        const ar = new osuBase.MapStats({
+            ar: this.beatmap.difficulty.ar,
+            mods: osuBase.ModUtil.removeSpeedChangingMods(this.mods),
+        }).calculate().ar;
+        osuBase.HitObjectStackEvaluator.applyStandardStacking(this.beatmap.formatVersion, this.beatmap.hitObjects.objects, ar, this.beatmap.general.stackLeniency);
+    }
     createSkills() {
         return [
             new OsuAim(this.mods, true),
@@ -3386,7 +3427,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         // Scale the aim value with slider factor to nerf very likely dropped sliderends.
         this.aim *= this.sliderNerfFactor;
         // Scale the aim value with accuracy.
-        this.aim *= this.computedAccuracy.value(this.totalHits);
+        this.aim *= this.computedAccuracy.value();
         // It is also important to consider accuracy difficulty when doing that.
         const odScaling = Math.pow(this.difficultyAttributes.overallDifficulty, 2) / 2500;
         this.aim *= 0.98 + odScaling;
@@ -3434,15 +3475,14 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             n300: Math.max(0, countGreat - relevantTotalDiff),
             n100: Math.max(0, countOk - Math.max(0, relevantTotalDiff - countGreat)),
             n50: Math.max(0, countMeh - Math.max(0, relevantTotalDiff - countGreat - countOk)),
-            nmiss: this.effectiveMissCount,
         });
         // Scale the speed value with accuracy and OD.
         this.speed *=
             (0.95 +
                 Math.pow(this.difficultyAttributes.overallDifficulty, 2) /
                     750) *
-                Math.pow((this.computedAccuracy.value(this.totalHits) +
-                    relevantAccuracy.value()) /
+                Math.pow((this.computedAccuracy.value() +
+                    relevantAccuracy.value(this.difficultyAttributes.speedNoteCount)) /
                     2, (14.5 -
                     Math.max(this.difficultyAttributes.overallDifficulty, 8)) /
                     2);
@@ -3472,7 +3512,8 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
         this.accuracy =
             Math.pow(1.52163, this.difficultyAttributes.overallDifficulty) *
-                Math.pow(realAccuracy.value(ncircles), 24) *
+                // It is possible to reach a negative accuracy with this formula. Cap it at zero - zero points.
+                Math.pow(realAccuracy.n300 < 0 ? 0 : realAccuracy.value(), 24) *
                 2.83;
         // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
         this.accuracy *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
@@ -3511,8 +3552,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                     ? 0.2 * Math.min(1, (this.totalHits - 200) / 200)
                     : 0);
         // Scale the flashlight value with accuracy slightly.
-        this.flashlight *=
-            0.5 + this.computedAccuracy.value(this.totalHits) / 2;
+        this.flashlight *= 0.5 + this.computedAccuracy.value() / 2;
         // It is also important to consider accuracy difficulty when doing that.
         const odScaling = Math.pow(this.difficultyAttributes.overallDifficulty, 2) / 2500;
         this.flashlight *= 0.98 + odScaling;